From e22400496904ed1078e1befc643e30c5a690ab51 Mon Sep 17 00:00:00 2001 From: Koennecke Mark Date: Fri, 21 Aug 2015 16:16:18 +0200 Subject: [PATCH] Integrated lakeshore 336 support into the SINQ IOC See lakeshore.cmd for the pains involved --- configure/RELEASE | 3 + iocBoot/iocsinqEPICS/envPaths | 1 + iocBoot/iocsinqEPICS/lakeshore.cmd | 56 + iocBoot/iocsinqEPICS/lakeshore.db | 25652 +++++++++++++++++ iocBoot/iocsinqEPICS/lakeshore.substitutions | 5 + sinqEPICSApp/src/Makefile | 2 +- sinqEPICSApp/src/sinq.dbd | 5 + 7 files changed, 25723 insertions(+), 1 deletion(-) create mode 100755 iocBoot/iocsinqEPICS/lakeshore.cmd create mode 100644 iocBoot/iocsinqEPICS/lakeshore.db create mode 100644 iocBoot/iocsinqEPICS/lakeshore.substitutions diff --git a/configure/RELEASE b/configure/RELEASE index 784b65c..38e15fc 100644 --- a/configure/RELEASE +++ b/configure/RELEASE @@ -34,3 +34,6 @@ MOTOR=/usr/local/epics/support/motor-6-7 ASYN=/usr/local/epics/support/asyn-4-18 STD=/usr/local/epics/support/std-3-1 ANC=/usr/local/epics/anc350v17 +STREAMS=/usr/local/epics/support/StreamDevice-2-6 +LAKESHORE336=/usr/local/epics/support/lakeshore336 +BUSY=/usr/local/epics/support/busy-1-4 \ No newline at end of file diff --git a/iocBoot/iocsinqEPICS/envPaths b/iocBoot/iocsinqEPICS/envPaths index c9e200e..fb699a5 100644 --- a/iocBoot/iocsinqEPICS/envPaths +++ b/iocBoot/iocsinqEPICS/envPaths @@ -4,3 +4,4 @@ epicsEnvSet("TOP","/afs/psi.ch/project/sinqdev/sinqepicsapp") epicsEnvSet("EPICS_BASE","/usr/local/epics") epicsEnvSet("ASYN","/usr/local/epics/support/asyn-4-18") epicsEnvSet("MOTOR","/usr/local/epics/support/motor-6-7") +epicsEnvSet("LAKESHORE336","/usr/local/epics/support/lakeshore336") diff --git a/iocBoot/iocsinqEPICS/lakeshore.cmd b/iocBoot/iocsinqEPICS/lakeshore.cmd new file mode 100755 index 0000000..0d1ab68 --- /dev/null +++ b/iocBoot/iocsinqEPICS/lakeshore.cmd @@ -0,0 +1,56 @@ +#!../../bin/linux-x86-debug/sinqEPICS + + +## You may have to change sinqEPICS to something else +## everywhere it appears in this file + +< envPaths + +cd ${TOP} + + +epicsEnvSet("STREAM_PROTOCOL_PATH", "$(LAKESHORE336)/protocol/") + +## Register all support components +dbLoadDatabase "dbd/sinqEPICS.dbd" +#dbLoadDatabase "dbd/sinq.dbd" +sinqEPICS_registerRecordDeviceDriver pdbbase + + +#---------- +drvAsynIPPortConfigure("serial1", "localhost:2020",0,0,0) + +dbLoadRecords("$(ASYN)/db/asynRecord.db","P=KM36:,R=serial1,PORT=serial1,ADDR=0,OMAX=80,IMAX=80") + +cd ${TOP}/iocBoot/${IOC} +# The db file had to be generated from the lakeshore.substitutions file using the command: +# msi -I/usr/local/epics/db -I/usr/local/epics/support/asyn-4-18/db -I/usr/local/epics/support/lakeshore336/db +# -I/usr/local/epics/support/devIocStats-3-1-7/db -I/usr/local/epics/db -Slakeshore.substitutions > lakeshore.db +# The substitutions file uses constructs which are only understood by msi but not from dbLoadTemplate +#dbLoadTemplate "lakeshore.substitutions" +dbLoadRecords("lakeshore.db") + +#----------------------------------------------------------------------------------- +# Getting this to work cost some pain: +# +# See the note above about translating the template with msi. +# +# The first was that stream device failed to include the AsynDriverInterface. I had +# to manually hack the Makefile to get this in. There must be a better way but I do +# not know it. +# +# Undocumented, but true: this requires the busy record to be available, had to be added +# too +# +# The next thing is that the LS366 simulator uses \r as terminator and not \r\n as +# asked for in the protocol file. I had to chnage ls366.protocol to account for this. +# I am not sure if this problem is a protocol problem or a simulator issue +# +# Definitly a simulator issue is that the simulator does not implement some commands. +# Which causes error messages. +#----------------------------------------------------------------------------------- + +iocInit + +## Start any sequence programs +#seq sncxxx,"user=koenneckeHost" diff --git a/iocBoot/iocsinqEPICS/lakeshore.db b/iocBoot/iocsinqEPICS/lakeshore.db new file mode 100644 index 0000000..3759f72 --- /dev/null +++ b/iocBoot/iocsinqEPICS/lakeshore.db @@ -0,0 +1,25652 @@ +################################################################ +# +# Lakeshore 336/350 Temperature Controller template file. +# +# Macros: +# P - Prefix for PV name +# PORT - Bus/Port Address (eg. ASYN Port). +# ADDR - Address on the bus (optional) +# TEMPSCAN - SCAN rate for the temperature/voltage readings +# SCAN - SCAN rate for non-temperature/voltage parameters. +# ADEL (optional) - Archive deadband for temperatures +# MDEL (optional) - Monitor deadband for temperatures +# +# Notes: The loop/output dependant PVs are in a seperate template file, included in this one. +# Generally, set records forward process the associated read records in order +# to update the read record faster than their SCAN rate otherwise would do (but they +# are not processed in the same processing chain). +# +# Matt Pearson, June 2013 +# +# June 2014 - modified to support Lakeshore 350. The 350 is almost +# identical to the 336 so I just had to modify menu +# options. I also added in support for the 3062 option card. +# +# June 2014 - factor out input sensor records into lakeshore_input.template +# and add support for reading input sensor descriptions. This +# is also used in lakeshore_option_3062.template. +# +################################################################ + +record(bo, "KM36:TST:LS:DISABLE") { + field(DESC, "Disable set records") + field(PINI, "YES") + field(VAL, "0") + field(OMSL, "supervisory") + field(ZNAM, "Set Enabled") + field(ONAM, "Set Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MAJOR") +} + +record(bo, "KM36:TST:LS:DISABLE_POLL") { + field(DESC, "Disable polling") + field(PINI, "YES") + field(VAL, "0") + field(OMSL, "supervisory") + field(ZNAM, "Poll Enabled") + field(ONAM, "Poll Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MAJOR") +} + +################################################################ +# Read records +################################################################ + +## +## Read the ID string from the device. +## +record(stringin, "KM36:TST:LS:ID") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getID serial1 0") + field(SCAN, "Passive") + field(PINI, "YES") +} + +## +## Read the model number from the device. +## +record(stringin, "KM36:TST:LS:MODEL") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getMODEL serial1 0") + field(SCAN, "I/O Intr") +} + +## +## Read the serial number from the device. +## +record(stringin, "KM36:TST:LS:SERIAL") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getSERIAL serial1 0") + field(SCAN, "I/O Intr") +} + +## +## Read the firmware from the device. +## +record(stringin, "KM36:TST:LS:FIRMWARE") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getFIRMWARE serial1 0") + field(SCAN, "I/O Intr") +} + + +## +## Read the tuning status from the device. +## +#record(stringin, "KM36:TST:LS:TUNEST") { +# field(DTYP, "stream") +# field(SDIS, "KM36:TST:LS:DISABLE_POLL") +# field(INP, "@ls336.proto getTUNEST serial1 0") +# field(SCAN, "5 second") +#} + +## +## Read the tuning status success parameter +## +#record(bi, "KM36:TST:LS:TUNESTSUCCESS") { +# field(DTYP, "stream") +# field(SDIS, "KM36:TST:LS:DISABLE_POLL") +# field(INP, "@ls336.proto getTUNESTSUCCESS serial1 0") +# field(SCAN, "5 second") +# field(ZNAM, "No Error") +# field(ONAM, "Error (see manual)") +#} + +################################################################ +# Input sensor records +################################################################ + +record(bo, "KM36:TST:LS:DISABLE_0") { + field(DESC, "Disable A polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + +record(bo, "KM36:TST:LS:DISABLE_1") { + field(DESC, "Disable B polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + +record(bo, "KM36:TST:LS:DISABLE_2") { + field(DESC, "Disable C polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + +record(bo, "KM36:TST:LS:DISABLE_3") { + field(DESC, "Disable D polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARM0_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDG0 CP MS") + field(INPB, "KM36:TST:LS:ALARM0_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARM0_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGST0 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARM0_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_0") +} + +record(calcout, "KM36:TST:LS:ALARM0_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARM0_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARM0_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARM0_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARM0_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_0 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARM0_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel 0 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDG0") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(DESC, "Channel 0 Temperature") + field(INP, "@ls336.proto getKRDG(A) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel 0. +## +record(ai, "KM36:TST:LS:SRDG0") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(INP, "@ls336.proto getSRDG(A) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor 0 name +## +record(stringout, "KM36:TST:LS:INNAME_S0") { + field(DESC, "Input 0 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(A) serial1 0") + field(FLNK, "KM36:TST:LS:INNAME0.PROC CA") +} + +## +## Read input sensor 0 name +## +record(stringin, "KM36:TST:LS:INNAME0") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(A) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input 0. +## This also populates ALARM0_LOW +## +record(bi, "KM36:TST:LS:ALARM0_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(INP, "@ls336.proto getALARMST(A,KM36:TST:LS:ALARM0_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input 0 +## +record(bi, "KM36:TST:LS:ALARM0_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM0") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(INP, "@ls336.proto getALARM(A,KM36:TST:LS:ALARM0) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM0_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARM0_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM0_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM0_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARM0_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARM0_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARM0_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGST0") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(A) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRV0") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(A) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPE0") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_0") + field(INP, "@ls336.proto getINTYPE(A,KM36:TST:LS:INTYPE0) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPE0_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPE0_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE0_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPE0_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE0_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARM1_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDG1 CP MS") + field(INPB, "KM36:TST:LS:ALARM1_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARM1_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGST1 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARM1_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_1") +} + +record(calcout, "KM36:TST:LS:ALARM1_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARM1_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARM1_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARM1_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARM1_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_1 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARM1_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel 1 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDG1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(DESC, "Channel 1 Temperature") + field(INP, "@ls336.proto getKRDG(B) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel 1. +## +record(ai, "KM36:TST:LS:SRDG1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(INP, "@ls336.proto getSRDG(B) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor 1 name +## +record(stringout, "KM36:TST:LS:INNAME_S1") { + field(DESC, "Input 1 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(B) serial1 0") + field(FLNK, "KM36:TST:LS:INNAME1.PROC CA") +} + +## +## Read input sensor 1 name +## +record(stringin, "KM36:TST:LS:INNAME1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(B) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input 1. +## This also populates ALARM1_LOW +## +record(bi, "KM36:TST:LS:ALARM1_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(INP, "@ls336.proto getALARMST(B,KM36:TST:LS:ALARM1_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input 1 +## +record(bi, "KM36:TST:LS:ALARM1_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM1") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(INP, "@ls336.proto getALARM(B,KM36:TST:LS:ALARM1) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM1_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARM1_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM1_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM1_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARM1_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARM1_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARM1_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGST1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(B) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRV1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(B) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPE1") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_1") + field(INP, "@ls336.proto getINTYPE(B,KM36:TST:LS:INTYPE1) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPE1_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPE1_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE1_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPE1_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE1_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARM2_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDG2 CP MS") + field(INPB, "KM36:TST:LS:ALARM2_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARM2_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGST2 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARM2_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_2") +} + +record(calcout, "KM36:TST:LS:ALARM2_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARM2_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARM2_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARM2_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARM2_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_2 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARM2_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel 2 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDG2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(DESC, "Channel 2 Temperature") + field(INP, "@ls336.proto getKRDG(C) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel 2. +## +record(ai, "KM36:TST:LS:SRDG2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(INP, "@ls336.proto getSRDG(C) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor 2 name +## +record(stringout, "KM36:TST:LS:INNAME_S2") { + field(DESC, "Input 2 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(C) serial1 0") + field(FLNK, "KM36:TST:LS:INNAME2.PROC CA") +} + +## +## Read input sensor 2 name +## +record(stringin, "KM36:TST:LS:INNAME2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(C) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input 2. +## This also populates ALARM2_LOW +## +record(bi, "KM36:TST:LS:ALARM2_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(INP, "@ls336.proto getALARMST(C,KM36:TST:LS:ALARM2_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input 2 +## +record(bi, "KM36:TST:LS:ALARM2_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM2") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(INP, "@ls336.proto getALARM(C,KM36:TST:LS:ALARM2) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM2_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARM2_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM2_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM2_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARM2_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARM2_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARM2_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGST2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(C) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRV2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(C) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPE2") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_2") + field(INP, "@ls336.proto getINTYPE(C,KM36:TST:LS:INTYPE2) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPE2_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPE2_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE2_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPE2_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE2_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARM3_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDG3 CP MS") + field(INPB, "KM36:TST:LS:ALARM3_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARM3_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGST3 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARM3_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_3") +} + +record(calcout, "KM36:TST:LS:ALARM3_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARM3_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARM3_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARM3_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARM3_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_3 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARM3_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel 3 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDG3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(DESC, "Channel 3 Temperature") + field(INP, "@ls336.proto getKRDG(D) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel 3. +## +record(ai, "KM36:TST:LS:SRDG3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(INP, "@ls336.proto getSRDG(D) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor 3 name +## +record(stringout, "KM36:TST:LS:INNAME_S3") { + field(DESC, "Input 3 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(D) serial1 0") + field(FLNK, "KM36:TST:LS:INNAME3.PROC CA") +} + +## +## Read input sensor 3 name +## +record(stringin, "KM36:TST:LS:INNAME3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(D) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input 3. +## This also populates ALARM3_LOW +## +record(bi, "KM36:TST:LS:ALARM3_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(INP, "@ls336.proto getALARMST(D,KM36:TST:LS:ALARM3_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input 3 +## +record(bi, "KM36:TST:LS:ALARM3_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM3") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(INP, "@ls336.proto getALARM(D,KM36:TST:LS:ALARM3) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARM3_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARM3_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM3_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARM3_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARM3_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARM3_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARM3_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGST3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(D) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRV3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(D) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPE3") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_3") + field(INP, "@ls336.proto getINTYPE(D,KM36:TST:LS:INTYPE3) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPE3_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPE3_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE3_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPE3_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPE3_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + +################################################################ + +################################################################ +# Include 3062 option +################################################################ + + +# This file provides records to read inputs D1 to D5 +# that are provided by the 3062 option. This option card +# can be used with both the 336 and 350. By default these +# records are disabled (there is a record to control this). + +# This file can be included in the lakeshore336.template +# so does not need to be instantiated separately. It will +# make use of the macros used in lakeshore336.template. + +# Seperate polling records to control which inputs we are +# reading. If an input is not being polled, it won't +# affect the top level lakeshore alarm. + +record(bo, "KM36:TST:LS:DISABLE_D2") { + field(DESC, "Disable D2 polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + +record(bo, "KM36:TST:LS:DISABLE_D3") { + field(DESC, "Disable D3 polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + +record(bo, "KM36:TST:LS:DISABLE_D4") { + field(DESC, "Disable D4 polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + +record(bo, "KM36:TST:LS:DISABLE_D5") { + field(DESC, "Disable D5 polling") + field(PINI, "YES") + field(VAL, "1") + field(OMSL, "supervisory") + field(ZNAM, "Enabled") + field(ONAM, "Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + info(autosaveFields, "VAL") +} + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARMD2_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDGD2 CP MS") + field(INPB, "KM36:TST:LS:ALARMD2_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARMD2_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGSTD2 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARMD2_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_D2") +} + +record(calcout, "KM36:TST:LS:ALARMD2_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARMD2_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARMD2_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARMD2_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARMD2_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_D2 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARMD2_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel D2 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDGD2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(DESC, "Channel D2 Temperature") + field(INP, "@ls336.proto getKRDG(D2) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel D2. +## +record(ai, "KM36:TST:LS:SRDGD2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(INP, "@ls336.proto getSRDG(D2) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor D2 name +## +record(stringout, "KM36:TST:LS:INNAME_SD2") { + field(DESC, "Input D2 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(D2) serial1 0") + field(FLNK, "KM36:TST:LS:INNAMED2.PROC CA") +} + +## +## Read input sensor D2 name +## +record(stringin, "KM36:TST:LS:INNAMED2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(D2) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input D2. +## This also populates ALARMD2_LOW +## +record(bi, "KM36:TST:LS:ALARMD2_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(INP, "@ls336.proto getALARMST(D2,KM36:TST:LS:ALARMD2_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input D2 +## +record(bi, "KM36:TST:LS:ALARMD2_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD2") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(INP, "@ls336.proto getALARM(D2,KM36:TST:LS:ALARMD2) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD2_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARMD2_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD2_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD2_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARMD2_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARMD2_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARMD2_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGSTD2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(D2) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRVD2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(D2) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPED2") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D2") + field(INP, "@ls336.proto getINTYPE(D2,KM36:TST:LS:INTYPED2) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPED2_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPED2_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED2_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPED2_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED2_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARMD3_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDGD3 CP MS") + field(INPB, "KM36:TST:LS:ALARMD3_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARMD3_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGSTD3 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARMD3_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_D3") +} + +record(calcout, "KM36:TST:LS:ALARMD3_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARMD3_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARMD3_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARMD3_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARMD3_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_D3 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARMD3_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel D3 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDGD3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(DESC, "Channel D3 Temperature") + field(INP, "@ls336.proto getKRDG(D3) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel D3. +## +record(ai, "KM36:TST:LS:SRDGD3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(INP, "@ls336.proto getSRDG(D3) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor D3 name +## +record(stringout, "KM36:TST:LS:INNAME_SD3") { + field(DESC, "Input D3 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(D3) serial1 0") + field(FLNK, "KM36:TST:LS:INNAMED3.PROC CA") +} + +## +## Read input sensor D3 name +## +record(stringin, "KM36:TST:LS:INNAMED3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(D3) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input D3. +## This also populates ALARMD3_LOW +## +record(bi, "KM36:TST:LS:ALARMD3_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(INP, "@ls336.proto getALARMST(D3,KM36:TST:LS:ALARMD3_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input D3 +## +record(bi, "KM36:TST:LS:ALARMD3_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD3") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(INP, "@ls336.proto getALARM(D3,KM36:TST:LS:ALARMD3) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD3_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARMD3_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD3_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD3_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARMD3_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARMD3_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARMD3_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGSTD3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(D3) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRVD3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(D3) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPED3") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D3") + field(INP, "@ls336.proto getINTYPE(D3,KM36:TST:LS:INTYPED3) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPED3_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPED3_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED3_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPED3_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED3_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARMD4_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDGD4 CP MS") + field(INPB, "KM36:TST:LS:ALARMD4_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARMD4_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGSTD4 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARMD4_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_D4") +} + +record(calcout, "KM36:TST:LS:ALARMD4_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARMD4_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARMD4_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARMD4_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARMD4_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_D4 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARMD4_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel D4 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDGD4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(DESC, "Channel D4 Temperature") + field(INP, "@ls336.proto getKRDG(D4) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel D4. +## +record(ai, "KM36:TST:LS:SRDGD4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(INP, "@ls336.proto getSRDG(D4) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor D4 name +## +record(stringout, "KM36:TST:LS:INNAME_SD4") { + field(DESC, "Input D4 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(D4) serial1 0") + field(FLNK, "KM36:TST:LS:INNAMED4.PROC CA") +} + +## +## Read input sensor D4 name +## +record(stringin, "KM36:TST:LS:INNAMED4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(D4) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input D4. +## This also populates ALARMD4_LOW +## +record(bi, "KM36:TST:LS:ALARMD4_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(INP, "@ls336.proto getALARMST(D4,KM36:TST:LS:ALARMD4_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input D4 +## +record(bi, "KM36:TST:LS:ALARMD4_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD4") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(INP, "@ls336.proto getALARM(D4,KM36:TST:LS:ALARMD4) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD4_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARMD4_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD4_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD4_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARMD4_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARMD4_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARMD4_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGSTD4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(D4) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRVD4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(D4) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPED4") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D4") + field(INP, "@ls336.proto getINTYPE(D4,KM36:TST:LS:INTYPED4) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPED4_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPED4_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED4_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPED4_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED4_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +# Template to provide the records required for an input. +# This makes use of the macros required by lakeshore336.template +# but also requires macros to specify the input channel and index. +# The index is to provide a way for the developer to use a different +# channel naming scheme. +# +# For some commands, I hard coded the last part of the record names into +# the protocol file. This seems the easiest way to deal with commands +# will lots of params returned back, and avoid problematic long INP fields. +# For the ZONE commands I used waveforms and subarrays, but that is not as simple. +# +# Macros: +# INPUT - A to D, or D1 to D5 +# INDEX - Index to use for the input channel PV name and DESC (eg. 0 to 3) +# DISABLE - PV name to use for SDIS + +## +## Alarm summary record for input +## This summarizes the software limits on the temperature readings, +## the alarm status reading from the controller and the input reading status. +## +record(calc, "KM36:TST:LS:ALARMD5_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:KRDGD5 CP MS") + field(INPB, "KM36:TST:LS:ALARMD5_HIGH CP MS") + field(INPC, "KM36:TST:LS:ALARMD5_LOW CP MS") + field(INPD, "KM36:TST:LS:RDGSTD5 CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARMD5_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_D5") +} + +record(calcout, "KM36:TST:LS:ALARMD5_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARMD5_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARMD5_SUMMARY PP") +} + +record(bi, "KM36:TST:LS:ALARMD5_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## If we disable polling this input, disable the alarm +## +record(calcout, "KM36:TST:LS:ALARMD5_SUMMARY_DISABLE") { + field(INPA, "KM36:TST:LS:DISABLE_D5 CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARMD5_SUMMARY.VAL PP") +} + + +## +## Read the temperature on channel D5 in Kelvin. +## +record(ai, "KM36:TST:LS:KRDGD5") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(DESC, "Channel D5 Temperature") + field(INP, "@ls336.proto getKRDG(D5) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + field(HHSV,"MAJOR") + field(HSV, "MINOR") + field(LSV, "MINOR") + field(LLSV,"MAJOR") + field(HYST,"1.0") + field(HIHI,"1000") + field(HIGH,"1000") + field(LOW,"-1") + field(LOLO,"-1") + field(ADEL, "1") + field(MDEL, "0") + info(autosaveFields, "HIHI HIGH LOW LOLO ADEL MDEL") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the raw voltage on channel D5. +## +record(ai, "KM36:TST:LS:SRDGD5") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(INP, "@ls336.proto getSRDG(D5) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "V") + field(ADEL, "1") + field(MDEL, "0") +} + +## +## Set sensor D5 name +## +record(stringout, "KM36:TST:LS:INNAME_SD5") { + field(DESC, "Input D5 Name") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setINNAME(D5) serial1 0") + field(FLNK, "KM36:TST:LS:INNAMED5.PROC CA") +} + +## +## Read input sensor D5 name +## +record(stringin, "KM36:TST:LS:INNAMED5") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(INP, "@ls336.proto getINNAME(D5) serial1 0") + field(PINI, "YES") + field(SCAN, "Passive") +} + +## +## Read the high alarm status for input D5. +## This also populates ALARMD5_LOW +## +record(bi, "KM36:TST:LS:ALARMD5_HIGH") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(INP, "@ls336.proto getALARMST(D5,KM36:TST:LS:ALARMD5_LOW) serial1 0") + field(SCAN, "5 second") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the low alarm status for input D5 +## +record(bi, "KM36:TST:LS:ALARMD5_LOW") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") + field(OSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the alarm parameters. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD5") { + field(DESC, "Read Alarm Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(INP, "@ls336.proto getALARM(D5,KM36:TST:LS:ALARMD5) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the alarm params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(bi, "KM36:TST:LS:ALARMD5_ONOFF") { + field(DESC, "Alarm Enabled") + field(ZNAM, "Disabled") + field(ONAM, "Enabled") +} +record(ai, "KM36:TST:LS:ALARMD5_HIGHVAL") { + field(DESC, "Alarm High Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD5_LOWVAL") { + field(DESC, "Alarm Low Value") + field(EGU, "K") +} +record(ai, "KM36:TST:LS:ALARMD5_DB") { + field(DESC, "Alarm Deadband") + field(EGU, "K") +} +record(bi, "KM36:TST:LS:ALARMD5_LE") { + field(DESC, "Alarm Latch Enable") + field(ZNAM, "Non Latching") + field(ONAM, "Latching") +} +record(bi, "KM36:TST:LS:ALARMD5_AU") { + field(DESC, "Alarm Audible") + field(ZNAM, "Quiet") + field(ONAM, "Audible") +} +record(bi, "KM36:TST:LS:ALARMD5_VIS") { + field(DESC, "Alarm Visible") + field(ZNAM, "Non Visible") + field(ONAM, "Visible") +} + + +## +## Read the input reading status +## +record(mbbi, "KM36:TST:LS:RDGSTD5") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(ZRST, "Valid") + field(ZRVL, "0") + field(ONST, "Invalid") + field(ONVL, "1") + field(TWST, "Temp Under") + field(TWVL, "16") + field(THST, "Temp Over") + field(THVL, "32") + field(FRST, "Sensor Zero") + field(FRVL, "64") + field(FVST, "Sensor Over") + field(FVVL, "128") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + field(THSV, "MAJOR") + field(FRSV, "MAJOR") + field(FVSV, "MAJOR") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRDGST(D5) serial1 0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the input curve number +## +record(longin, "KM36:TST:LS:INCRVD5") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getINCRV(D5) serial1 0") +} + + +## +## Read the input type information. +## NOTE: the last part of the record name is hard coded into protocol file. +## +record(bi, "KM36:TST:LS:INTYPED5") { + field(DESC, "Read Input Type Params") + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_D5") + field(INP, "@ls336.proto getINTYPE(D5,KM36:TST:LS:INTYPED5) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the rest of the input type params. +## NOTE: the last part of the record names are hard coded into protocol file. +## +record(mbbi, "KM36:TST:LS:INTYPED5_S") { + field(DESC, "Sensor Type") + field(ZRST, "Disabled") + field(ZRVL, "0") + field(ONST, "Diode") + field(ONVL, "1") + field(TWST, "Platinum RTD") + field(TWVL, "2") + field(THST, "NTC RTD") + field(THVL, "3") + field(FRST, "Thermocouple") + field(FRVL, "4") + field(FVST, "Capacitance") + field(FVVL, "5") +} +record(bi, "KM36:TST:LS:INTYPED5_AR") { + field(DESC, "Auto Range") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED5_R") { + field(DESC, "Range") + field(ZRST, "10 Ohm / 2.5V / 50mV") + field(ZRVL, "0") + field(ONST, "30 Ohm / 10V") + field(ONVL, "1") + field(TWST, "100 Ohm") + field(TWVL, "2") + field(THST, "300 Ohm") + field(THVL, "3") + field(FRST, "1 KOhm") + field(FRVL, "4") + field(FVST, "3 KOhm") + field(FVVL, "5") + field(SXST, "10 KOhm") + field(SXVL, "6") + field(SVST, "30 KOhm") + field(SVVL, "7") + field(EIST, "100 KOhm") + field(EIVL, "8") +} +record(bi, "KM36:TST:LS:INTYPED5_C") { + field(DESC, "Compensation") + field(ZNAM, "Off") + field(ONAM, "On") +} +record(mbbi, "KM36:TST:LS:INTYPED5_U") { + field(DESC, "Units") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Kelvin") + field(ONVL, "1") + field(TWST, "Celcius") + field(TWVL, "2") + field(THST, "Sensor") + field(THVL, "3") +} + + + + +################################################################ +# Now include the loop dependant records, for outputs 1, 2, 3 and 4. +# The common records are in lakeshore336output.template. +################################################################ + +#substitute "TOLERANCE=1" + +# This is included in lakeshore336.template +# This template is for the common functionality shared by all 4 outputs. +# +# There is some logic in this database to provide put_callback functionality +# for setting the temperature and waiting for it to be in range. The input +# sensor PV name used for the in-window calculation changes depending on +# the input sensor selected. In order for this to work it requires the following +# macros: +# +# INPUTA - Sensor 1 PV name +# INPUTB - Sensor 2 PV name +# INPUTC - Sensor 3 PV name +# INPUTD - Sensor 4 PV name +# INPUTD2 - Sensor D2 PV name +# INPUTD3 - Sensor D3 PV name +# INPUTD4 - Sensor D4 PV name +# INPUTD5 - Sensor D5 PV name +# TOLERANCE (optional - defaults to 1) +# +# The input link names must fit into a stringout record for this to work. +# The above link names default to a dummy record. + +################################################################ +# Read records +################################################################ + +## +## Record holding the output number +## +record(stringout, "KM36:TST:LS:OUTPUT1") { + field(DTYP, "Soft Channel") + field(VAL, "1") + field(PINI, "YES") +} + +## +## Read the setpoint temperature. +## +record(ai, "KM36:TST:LS:SETP1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getSETP(1) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the setpoint limit +## + +## +## Read the ramp parameter. This also populates the ramp status KM36:TST:LS:RAMPST1, +## +record(ai, "KM36:TST:LS:RAMP1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getRAMP(1,KM36:TST:LS:RAMPST1) serial1 0") + field(SCAN, "5 second") + field(PREC, "3") + field(EGU, "K/min") +} + +## +## Read the ramp status parameter. +## +## 0=off +## 1=on +## +record(bi, "KM36:TST:LS:RAMPST1") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Read the range parameter (the heater output power range). +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:RANGE1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRANGE(1) serial1 0") +} + +## +## Read the mode to use for outmode +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:OMMODE1") { +} + +## +## Read the manual output parameter. +## +record(ai, "KM36:TST:LS:MOUT1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getMOUT(1) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID P parameter. Pass the I and D records into the protocol to read those as well. +## +record(ai, "KM36:TST:LS:P1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getPID(1,KM36:TST:LS:I1,KM36:TST:LS:D1) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID I parameter. +## +record(ai, "KM36:TST:LS:I1") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the PID D parameter. +## +record(ai, "KM36:TST:LS:D1") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the mode to use for outmode. +## This also populates the OMI and OMP records. +## The mbbi strings and values are defined in the output specific templates. +## +record(mbbi, "KM36:TST:LS:OMM1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getOM(1,KM36:TST:LS:OMI1,KM36:TST:LS:OMP1) serial1 0") +} + +## +## Read the input to use for outmode +## +record(mbbi, "KM36:TST:LS:OMI1") { + field(DTYP, "Soft Channel") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") +} + +## +## Read the power up mode to use for outmode +## +record(mbbi, "KM36:TST:LS:OMP1") { + field(DTYP, "Soft Channel") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") +} + +################################################################ +# Write records +################################################################ + +## +## Set the setpoint temperature. +## +record(ao, "KM36:TST:LS:SETP_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Setpoint temperature") + field(OUT, "@ls336.proto setSETP(1) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:SETP_S1_BUSYSET.PROC") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +############################################################################### + +## +## A few records to support put_callback on the setpoint. We use the busy record. +## A temperature window is used. The temperature must be within +## the window, before the callback is done. +## + +record(dfanout, "KM36:TST:LS:SETP_S1_BUSYSET") +{ + field(VAL, "0") + field(OUTA, "KM36:TST:LS:IN_WINDOW1.VAL PP") + field(FLNK, "KM36:TST:LS:SETP_S1_BUSYSET2") +} +record(dfanout, "KM36:TST:LS:SETP_S1_BUSYSET2") +{ + field(VAL, "1") + field(OUTA, "KM36:TST:LS:SETP1.PROC PP") + field(OUTB, "KM36:TST:LS:SETP_S1_BUSY PP") + field(FLNK, "KM36:TST:LS:CALC_IN_WINDOW1") +} +record(busy, "KM36:TST:LS:SETP_S1_BUSY") +{ +} +record(calcout, "KM36:TST:LS:CALC_IN_WINDOW1") { + field(PINI, "YES") + field(INPA, "1") + field(INPB, "KM36:TST:LS:DUMMY1.VAL") + field(INPC, "KM36:TST:LS:SETP_S1.VAL") + field(CALC, "((B>=(C-A))&&(B<=(C+A)))?1:0") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:IN_WINDOW1.VAL PP") + field(DOPT, "Use CALC") + field(SCAN, "1 second") + field(PREC, "1") + info(autosaveFields, "A") + info(archive, "Monitor, 00:00:01, A B C VAL") +} +record(bo, "KM36:TST:LS:IN_WINDOW1") { + field(DESC, "Temperature In Window") + field(VAL, "0") + field(PINI, "YES") + field(OMSL, "supervisory") + field(ZNAM, "Not In Window") + field(ONAM, "In Window") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Set busy record 'done' when TIME_WINDOW1=1 +## +record(calcout, "KM36:TST:LS:CALC_BUSY_DONE1") { + field(INPA, "KM36:TST:LS:IN_WINDOW1.VAL CP") + field(CALC, "(A=1)?0:1") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:SETP_S1_BUSY.VAL PP") +} + +############################################################################### + +## +## Dummy record to use for input link name default +## +record(ai, "KM36:TST:LS:DUMMY1") { +} + +## +## Monitor KM36:TST:LS:OMI1 to determin which input sensor to use +## to deal with the callback. The below set of records automatically +## switch the input when the 'control input' is changed. They make +## use of the input sensor PV names passed into this template. +## +record(calcout, "KM36:TST:LS:SET_1_INPUTA") { + field(CALC, "A=1") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTA_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTA_LINK") { + field(VAL, "KM36:TST:LS:KRDG0.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTB") { + field(CALC, "A=2") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTB_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTB_LINK") { + field(VAL, "KM36:TST:LS:KRDG1.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTC") { + field(CALC, "A=3") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTC_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTC_LINK") { + field(VAL, "KM36:TST:LS:KRDG2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTD") { + field(CALC, "A=4") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTD_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTD_LINK") { + field(VAL, "KM36:TST:LS:KRDG3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTD2") { + field(CALC, "A=5") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTD2_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTD2_LINK") { + field(VAL, "KM36:TST:LS:KRDGD2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTD3") { + field(CALC, "A=6") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTD3_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTD3_LINK") { + field(VAL, "KM36:TST:LS:KRDGD3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTD4") { + field(CALC, "A=7") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTD4_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTD4_LINK") { + field(VAL, "KM36:TST:LS:KRDGD4.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_1_INPUTD5") { + field(CALC, "A=8") + field(INPA, "KM36:TST:LS:OMI1.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_1_INPUTD5_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_1_INPUTD5_LINK") { + field(VAL, "KM36:TST:LS:KRDGD5.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW1.INPB CA") +} + + + +## +## Set the range parameter. +## The strings are output specific and is defined in another file. +## +record(mbbo, "KM36:TST:LS:RANGE_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRANGE(1) serial1 0") + field(FLNK, "KM36:TST:LS:RANGE1.PROC CA") +} + +## +## Set the ramp rate parameter. +## +## This is the desired temperate increase/decrease rate +## per second when heating/cooling. +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp status, as well as the +## desired ramp. This is done automatically by reading the +## PV which holds the current ramp status. +## +record(ao, "KM36:TST:LS:RAMP_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMP(KM36:TST:LS:RAMPST1,1) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:RAMP1.PROC CA") + field(EGU, "K/min") +} + +## +## Set the ramp status parameter. +## +## 0=off +## 1=on +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp, as well as the +## desired ramp status. This is done automatically by reading the +## PV which holds the current ramp value. +## +record(bo, "KM36:TST:LS:RAMPST_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMPSTATUS(KM36:TST:LS:RAMP1,1) serial1 0") + field(FLNK, "KM36:TST:LS:RAMP1.PROC CA") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Set the manual output value. +## +record(ao, "KM36:TST:LS:MOUT_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setMOUT(1) serial1 0") + field(FLNK, "KM36:TST:LS:MOUT1.PROC CA") +} + +## +## Set the PID P parameter. +## +record(ao, "KM36:TST:LS:P_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setP(1,KM36:TST:LS:I1,KM36:TST:LS:D1) serial1 0") + field(FLNK, "KM36:TST:LS:P1.PROC CA") +} + +## +## Set the PID I parameter. +## +record(ao, "KM36:TST:LS:I_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setI(KM36:TST:LS:P1,1,KM36:TST:LS:D1) serial1 0") + field(FLNK, "KM36:TST:LS:P1.PROC CA") +} + +## +## Set the PID D parameter. +## +record(ao, "KM36:TST:LS:D_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setD(KM36:TST:LS:P1,KM36:TST:LS:I1,1) serial1 0") + field(FLNK, "KM36:TST:LS:P1.PROC CA") +} + +## +## Set the mode to use for outmode +## The strings are output specific. This is defined in another file. +## +record(mbbo, "KM36:TST:LS:OMM_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(OUT, "@ls336.proto setOM(1,KM36:TST:LS:OMI1,KM36:TST:LS:OMP1) serial1 0") + field(FLNK, "KM36:TST:LS:OMM1.PROC CA") +} + +## +## Set the input to use for outmode +## +record(mbbo, "KM36:TST:LS:OMI_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(OUT, "@ls336.proto setOMI(1,KM36:TST:LS:OMM1,KM36:TST:LS:OMP1) serial1 0") + field(FLNK, "KM36:TST:LS:OMM1.PROC CA") +} + +## +## Set the power up mode to use for outmode +## +record(mbbo, "KM36:TST:LS:OMP_S1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") + field(OUT, "@ls336.proto setOMP(1,KM36:TST:LS:OMM1,KM36:TST:LS:OMI1) serial1 0") + field(FLNK, "KM36:TST:LS:OMM1.PROC CA") +} + +## +## Set the type of tuning mode +## +record(mbbo, "KM36:TST:LS:TUNEMODE_S1") { + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "P Only") + field(ZRVL, "0") + field(ONST, "P and I") + field(ONVL, "1") + field(TWST, "P, I and D") + field(TWVL, "2") +} + + +## +## Start the tuning process +## +record(ao, "KM36:TST:LS:TUNESTART1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Start the auto tuning") + field(OUT, "@ls336.proto setATUNE(1,KM36:TST:LS:TUNEMODE_S1) serial1 0") +} + + +## +## Read all ZONE settings +## +record(seq, "KM36:TST:LS:Z:READ1") { + field(DESC, "Read Output 1 ZONE") + field(DOL1, "1") + field(DLY1, "0.1") + field(LNK1, "KM36:TST:LS:Z1:ALL1.PROC") + field(DOL2, "1") + field(DLY2, "0.1") + field(LNK2, "KM36:TST:LS:Z2:ALL1.PROC") + field(DOL3, "1") + field(DLY3, "0.1") + field(LNK3, "KM36:TST:LS:Z3:ALL1.PROC") + field(DOL4, "1") + field(DLY4, "0.1") + field(LNK4, "KM36:TST:LS:Z4:ALL1.PROC") + field(DOL5, "1") + field(DLY5, "0.1") + field(LNK5, "KM36:TST:LS:Z5:ALL1.PROC") + field(DOL6, "1") + field(DLY6, "0.1") + field(LNK6, "KM36:TST:LS:Z6:ALL1.PROC") + field(DOL7, "1") + field(DLY7, "0.1") + field(LNK7, "KM36:TST:LS:Z7:ALL1.PROC") + field(DOL8, "1") + field(DLY8, "0.1") + field(LNK8, "KM36:TST:LS:Z8:ALL1.PROC") + field(DOL9, "1") + field(DLY9, "0.1") + field(LNK9, "KM36:TST:LS:Z9:ALL1.PROC") + field(DOLA, "1") + field(DLYA, "0.1") + field(LNKA, "KM36:TST:LS:Z10:ALL1.PROC") + field(PINI, "YES") +} + +############################################### +# This is included in lakeshore336.template +# This template is for outputs 1 and 2, which can provide heater power. + +################################################################ +# Read records +################################################################ + +## +## Read the heater output value. +## +record(ai, "KM36:TST:LS:HTR1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getHTR(1) serial1 0") + field(SCAN, "5 second") + field(PREC, "1") + field(EGU, "%") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Define the strings and values for this record. +## +record(mbbi, "KM36:TST:LS:RANGE1") { + field(ZRST, "Off") + field(ONST, "Range1/Low") + field(TWST, "Range2/Medium") + field(THST, "Range3/High") + field(FRST, "Range4") + field(FVST, "Range5") +} + +## +## Define the strings and values for this record. +## +record(mbbi, "KM36:TST:LS:OMM1") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:RANGE_S1") { + field(ZRST, "Off") + field(ONST, "Range1/Low") + field(TWST, "Range2/Medium") + field(THST, "Range3/High") + field(FRST, "Range4") + field(FVST, "Range5") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:OMM_S1") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") +} + +## +## Read the heater status +## +record(longin, "KM36:TST:LS:HTRST1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(SCAN, "5 second") + field(INP, "@ls336.proto getHTRST(D5) serial1 0") + field(FLNK, "KM36:TST:LS:HTRST1_CALC") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Cache the heater status because this is cleared on a read on the controller. +## +record(calcout, "KM36:TST:LS:HTRST1_CALC") { + field(INPA, "KM36:TST:LS:HTRST1.VAL") + field(CALC, "A!=0?A:0") + field(DOPT, "Use CALC") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:HTRST1_CACHE.RVAL PP") +} +record(mbbi, "KM36:TST:LS:HTRST1_CACHE") { + field(DESC, "Cached HTRST") + field(DTYP, "Raw Soft Channel") + field(ZRST, "No Error") + field(ZRVL, "0") + field(ONST, "Open Load") + field(ONVL, "1") + field(TWST, "Short/Compliance") + field(TWVL, "2") + field(VAL, "0") + field(PINI, "YES") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Provide record to reset the cached value +## +record(bo, "KM36:TST:LS:HTRST1_RESET") { + field(DESC, "Reset Cached HTRST") + field(VAL, "0") + field(OUT, "KM36:TST:LS:HTRST1_CACHE.RVAL PP") +} + +############################################### +# Add in ZONE support +############################################### + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z1:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,1) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z1:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z1:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z1:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P1.PROC") +} +record(ai, "KM36:TST:LS:Z1:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z1:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I1.PROC") +} +record(ai, "KM36:TST:LS:Z1:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z1:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D1.PROC") +} +record(ai, "KM36:TST:LS:Z1:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z1:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z1:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z1:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:RANGE1") { + field(INP, "KM36:TST:LS:Z1:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z1:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z1:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:INPUT1") { + field(INP, "KM36:TST:LS:Z1:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z1:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z1:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z1:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z1:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z1:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z1:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:P1.VAL") + field(OUTA, "KM36:TST:LS:Z1:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:I1.VAL") + field(OUTA, "KM36:TST:LS:Z1:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:D1.VAL") + field(OUTA, "KM36:TST:LS:Z1:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z1:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z1:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z1:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z1:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z1:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z1:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z1:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z1:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z1:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z1:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z1:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z1:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z1:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z1:SET1") { + field(INPA, "KM36:TST:LS:Z1:UB_S1") + field(INPB, "KM36:TST:LS:Z1:P_S1") + field(INPC, "KM36:TST:LS:Z1:I_S1") + field(INPD, "KM36:TST:LS:Z1:D_S1") + field(INPE, "KM36:TST:LS:Z1:MOUT_S1") + field(INPF, "KM36:TST:LS:Z1:RANGE_S1") + field(INPG, "KM36:TST:LS:Z1:INPUT_S1") + field(INPH, "KM36:TST:LS:Z1:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,1) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z1:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P1.PROC") +} +record(ai, "KM36:TST:LS:Z2:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I1.PROC") +} +record(ai, "KM36:TST:LS:Z2:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D1.PROC") +} +record(ai, "KM36:TST:LS:Z2:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE1") { + field(INP, "KM36:TST:LS:Z2:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT1") { + field(INP, "KM36:TST:LS:Z2:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P1.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I1.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D1.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET1") { + field(INPA, "KM36:TST:LS:Z2:UB_S1") + field(INPB, "KM36:TST:LS:Z2:P_S1") + field(INPC, "KM36:TST:LS:Z2:I_S1") + field(INPD, "KM36:TST:LS:Z2:D_S1") + field(INPE, "KM36:TST:LS:Z2:MOUT_S1") + field(INPF, "KM36:TST:LS:Z2:RANGE_S1") + field(INPG, "KM36:TST:LS:Z2:INPUT_S1") + field(INPH, "KM36:TST:LS:Z2:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P1.PROC") +} +record(ai, "KM36:TST:LS:Z2:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I1.PROC") +} +record(ai, "KM36:TST:LS:Z2:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D1.PROC") +} +record(ai, "KM36:TST:LS:Z2:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE1") { + field(INP, "KM36:TST:LS:Z2:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT1") { + field(INP, "KM36:TST:LS:Z2:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P1.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I1.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D1.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET1") { + field(INPA, "KM36:TST:LS:Z2:UB_S1") + field(INPB, "KM36:TST:LS:Z2:P_S1") + field(INPC, "KM36:TST:LS:Z2:I_S1") + field(INPD, "KM36:TST:LS:Z2:D_S1") + field(INPE, "KM36:TST:LS:Z2:MOUT_S1") + field(INPF, "KM36:TST:LS:Z2:RANGE_S1") + field(INPG, "KM36:TST:LS:Z2:INPUT_S1") + field(INPH, "KM36:TST:LS:Z2:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z3:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,3) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z3:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z3:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z3:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P1.PROC") +} +record(ai, "KM36:TST:LS:Z3:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z3:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I1.PROC") +} +record(ai, "KM36:TST:LS:Z3:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z3:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D1.PROC") +} +record(ai, "KM36:TST:LS:Z3:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z3:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z3:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z3:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:RANGE1") { + field(INP, "KM36:TST:LS:Z3:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z3:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z3:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:INPUT1") { + field(INP, "KM36:TST:LS:Z3:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z3:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z3:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z3:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z3:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z3:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z3:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:P1.VAL") + field(OUTA, "KM36:TST:LS:Z3:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:I1.VAL") + field(OUTA, "KM36:TST:LS:Z3:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:D1.VAL") + field(OUTA, "KM36:TST:LS:Z3:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z3:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z3:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z3:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z3:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z3:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z3:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z3:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z3:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z3:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z3:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z3:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z3:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z3:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z3:SET1") { + field(INPA, "KM36:TST:LS:Z3:UB_S1") + field(INPB, "KM36:TST:LS:Z3:P_S1") + field(INPC, "KM36:TST:LS:Z3:I_S1") + field(INPD, "KM36:TST:LS:Z3:D_S1") + field(INPE, "KM36:TST:LS:Z3:MOUT_S1") + field(INPF, "KM36:TST:LS:Z3:RANGE_S1") + field(INPG, "KM36:TST:LS:Z3:INPUT_S1") + field(INPH, "KM36:TST:LS:Z3:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,3) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z3:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z4:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,4) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z4:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z4:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z4:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P1.PROC") +} +record(ai, "KM36:TST:LS:Z4:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z4:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I1.PROC") +} +record(ai, "KM36:TST:LS:Z4:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z4:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D1.PROC") +} +record(ai, "KM36:TST:LS:Z4:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z4:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z4:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z4:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:RANGE1") { + field(INP, "KM36:TST:LS:Z4:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z4:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z4:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:INPUT1") { + field(INP, "KM36:TST:LS:Z4:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z4:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z4:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z4:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z4:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z4:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z4:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:P1.VAL") + field(OUTA, "KM36:TST:LS:Z4:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:I1.VAL") + field(OUTA, "KM36:TST:LS:Z4:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:D1.VAL") + field(OUTA, "KM36:TST:LS:Z4:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z4:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z4:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z4:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z4:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z4:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z4:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z4:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z4:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z4:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z4:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z4:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z4:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z4:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z4:SET1") { + field(INPA, "KM36:TST:LS:Z4:UB_S1") + field(INPB, "KM36:TST:LS:Z4:P_S1") + field(INPC, "KM36:TST:LS:Z4:I_S1") + field(INPD, "KM36:TST:LS:Z4:D_S1") + field(INPE, "KM36:TST:LS:Z4:MOUT_S1") + field(INPF, "KM36:TST:LS:Z4:RANGE_S1") + field(INPG, "KM36:TST:LS:Z4:INPUT_S1") + field(INPH, "KM36:TST:LS:Z4:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,4) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z4:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z5:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,5) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z5:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z5:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z5:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P1.PROC") +} +record(ai, "KM36:TST:LS:Z5:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z5:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I1.PROC") +} +record(ai, "KM36:TST:LS:Z5:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z5:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D1.PROC") +} +record(ai, "KM36:TST:LS:Z5:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z5:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z5:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z5:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:RANGE1") { + field(INP, "KM36:TST:LS:Z5:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z5:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z5:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:INPUT1") { + field(INP, "KM36:TST:LS:Z5:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z5:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z5:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z5:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z5:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z5:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z5:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:P1.VAL") + field(OUTA, "KM36:TST:LS:Z5:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:I1.VAL") + field(OUTA, "KM36:TST:LS:Z5:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:D1.VAL") + field(OUTA, "KM36:TST:LS:Z5:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z5:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z5:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z5:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z5:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z5:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z5:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z5:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z5:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z5:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z5:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z5:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z5:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z5:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z5:SET1") { + field(INPA, "KM36:TST:LS:Z5:UB_S1") + field(INPB, "KM36:TST:LS:Z5:P_S1") + field(INPC, "KM36:TST:LS:Z5:I_S1") + field(INPD, "KM36:TST:LS:Z5:D_S1") + field(INPE, "KM36:TST:LS:Z5:MOUT_S1") + field(INPF, "KM36:TST:LS:Z5:RANGE_S1") + field(INPG, "KM36:TST:LS:Z5:INPUT_S1") + field(INPH, "KM36:TST:LS:Z5:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,5) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z5:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z6:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,6) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z6:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z6:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z6:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P1.PROC") +} +record(ai, "KM36:TST:LS:Z6:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z6:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I1.PROC") +} +record(ai, "KM36:TST:LS:Z6:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z6:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D1.PROC") +} +record(ai, "KM36:TST:LS:Z6:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z6:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z6:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z6:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:RANGE1") { + field(INP, "KM36:TST:LS:Z6:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z6:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z6:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:INPUT1") { + field(INP, "KM36:TST:LS:Z6:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z6:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z6:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z6:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z6:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z6:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z6:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:P1.VAL") + field(OUTA, "KM36:TST:LS:Z6:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:I1.VAL") + field(OUTA, "KM36:TST:LS:Z6:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:D1.VAL") + field(OUTA, "KM36:TST:LS:Z6:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z6:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z6:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z6:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z6:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z6:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z6:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z6:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z6:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z6:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z6:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z6:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z6:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z6:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z6:SET1") { + field(INPA, "KM36:TST:LS:Z6:UB_S1") + field(INPB, "KM36:TST:LS:Z6:P_S1") + field(INPC, "KM36:TST:LS:Z6:I_S1") + field(INPD, "KM36:TST:LS:Z6:D_S1") + field(INPE, "KM36:TST:LS:Z6:MOUT_S1") + field(INPF, "KM36:TST:LS:Z6:RANGE_S1") + field(INPG, "KM36:TST:LS:Z6:INPUT_S1") + field(INPH, "KM36:TST:LS:Z6:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,6) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z6:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z7:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,7) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z7:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z7:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z7:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P1.PROC") +} +record(ai, "KM36:TST:LS:Z7:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z7:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I1.PROC") +} +record(ai, "KM36:TST:LS:Z7:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z7:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D1.PROC") +} +record(ai, "KM36:TST:LS:Z7:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z7:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z7:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z7:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:RANGE1") { + field(INP, "KM36:TST:LS:Z7:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z7:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z7:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:INPUT1") { + field(INP, "KM36:TST:LS:Z7:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z7:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z7:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z7:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z7:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z7:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z7:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:P1.VAL") + field(OUTA, "KM36:TST:LS:Z7:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:I1.VAL") + field(OUTA, "KM36:TST:LS:Z7:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:D1.VAL") + field(OUTA, "KM36:TST:LS:Z7:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z7:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z7:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z7:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z7:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z7:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z7:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z7:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z7:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z7:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z7:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z7:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z7:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z7:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z7:SET1") { + field(INPA, "KM36:TST:LS:Z7:UB_S1") + field(INPB, "KM36:TST:LS:Z7:P_S1") + field(INPC, "KM36:TST:LS:Z7:I_S1") + field(INPD, "KM36:TST:LS:Z7:D_S1") + field(INPE, "KM36:TST:LS:Z7:MOUT_S1") + field(INPF, "KM36:TST:LS:Z7:RANGE_S1") + field(INPG, "KM36:TST:LS:Z7:INPUT_S1") + field(INPH, "KM36:TST:LS:Z7:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,7) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z7:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z8:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,8) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z8:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z8:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z8:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P1.PROC") +} +record(ai, "KM36:TST:LS:Z8:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z8:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I1.PROC") +} +record(ai, "KM36:TST:LS:Z8:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z8:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D1.PROC") +} +record(ai, "KM36:TST:LS:Z8:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z8:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z8:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z8:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:RANGE1") { + field(INP, "KM36:TST:LS:Z8:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z8:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z8:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:INPUT1") { + field(INP, "KM36:TST:LS:Z8:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z8:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z8:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z8:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z8:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z8:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z8:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:P1.VAL") + field(OUTA, "KM36:TST:LS:Z8:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:I1.VAL") + field(OUTA, "KM36:TST:LS:Z8:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:D1.VAL") + field(OUTA, "KM36:TST:LS:Z8:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z8:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z8:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z8:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z8:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z8:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z8:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z8:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z8:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z8:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z8:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z8:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z8:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z8:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z8:SET1") { + field(INPA, "KM36:TST:LS:Z8:UB_S1") + field(INPB, "KM36:TST:LS:Z8:P_S1") + field(INPC, "KM36:TST:LS:Z8:I_S1") + field(INPD, "KM36:TST:LS:Z8:D_S1") + field(INPE, "KM36:TST:LS:Z8:MOUT_S1") + field(INPF, "KM36:TST:LS:Z8:RANGE_S1") + field(INPG, "KM36:TST:LS:Z8:INPUT_S1") + field(INPH, "KM36:TST:LS:Z8:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,8) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z8:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z9:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,9) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z9:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z9:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z9:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P1.PROC") +} +record(ai, "KM36:TST:LS:Z9:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z9:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I1.PROC") +} +record(ai, "KM36:TST:LS:Z9:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z9:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D1.PROC") +} +record(ai, "KM36:TST:LS:Z9:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z9:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z9:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z9:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:RANGE1") { + field(INP, "KM36:TST:LS:Z9:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z9:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z9:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:INPUT1") { + field(INP, "KM36:TST:LS:Z9:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z9:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z9:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z9:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z9:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z9:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z9:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:P1.VAL") + field(OUTA, "KM36:TST:LS:Z9:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:I1.VAL") + field(OUTA, "KM36:TST:LS:Z9:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:D1.VAL") + field(OUTA, "KM36:TST:LS:Z9:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z9:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z9:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z9:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z9:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z9:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z9:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z9:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z9:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z9:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z9:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z9:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z9:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z9:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z9:SET1") { + field(INPA, "KM36:TST:LS:Z9:UB_S1") + field(INPB, "KM36:TST:LS:Z9:P_S1") + field(INPC, "KM36:TST:LS:Z9:I_S1") + field(INPD, "KM36:TST:LS:Z9:D_S1") + field(INPE, "KM36:TST:LS:Z9:MOUT_S1") + field(INPF, "KM36:TST:LS:Z9:RANGE_S1") + field(INPG, "KM36:TST:LS:Z9:INPUT_S1") + field(INPH, "KM36:TST:LS:Z9:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,9) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z9:ALL1.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z10:ALL1") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(1,10) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB1:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z10:UB1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB1.PROC") +} +record(ai, "KM36:TST:LS:Z10:UB1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:UB1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P1:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z10:P1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P1.PROC") +} +record(ai, "KM36:TST:LS:Z10:P1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:P1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I1:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z10:I1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I1.PROC") +} +record(ai, "KM36:TST:LS:Z10:I1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:I1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D1:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z10:D1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D1.PROC") +} +record(ai, "KM36:TST:LS:Z10:D1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:D1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT1:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z10:MOUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT1.PROC") +} +record(ai, "KM36:TST:LS:Z10:MOUT1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:MOUT1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE1:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z10:RANGE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE1.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:RANGE1") { + field(INP, "KM36:TST:LS:Z10:RANGE1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z10:INPUT1:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z10:INPUT1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INPUT1.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:INPUT1") { + field(INP, "KM36:TST:LS:Z10:INPUT1:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z10:RATE1:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z10:RATE1:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL1.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RATE1.PROC") +} +record(ai, "KM36:TST:LS:Z10:RATE1") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:RATE1:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INITCALC1.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z10:INITCALC1") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z10:INITUB1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITUB1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:UB1.VAL") + field(OUTA, "KM36:TST:LS:Z10:UB_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITP1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITP1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:P1.VAL") + field(OUTA, "KM36:TST:LS:Z10:P_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITI1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITI1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:I1.VAL") + field(OUTA, "KM36:TST:LS:Z10:I_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITD1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITD1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:D1.VAL") + field(OUTA, "KM36:TST:LS:Z10:D_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITMOUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITMOUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:MOUT1.VAL") + field(OUTA, "KM36:TST:LS:Z10:MOUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRANGE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRANGE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RANGE1.VAL") + field(OUTA, "KM36:TST:LS:Z10:RANGE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITINPUT1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITINPUT1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:INPUT1.VAL") + field(OUTA, "KM36:TST:LS:Z10:INPUT_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRATE1.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRATE1") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RATE1.VAL") + field(OUTA, "KM36:TST:LS:Z10:RATE_S1.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITCOUNT1.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITCOUNT1") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z10:INITCALC1.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z10:UB_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z10:P_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z10:I_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z10:D_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z10:MOUT_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z10:RANGE_S1") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z10:INPUT_S1") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z10:RATE_S1") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z10:SET1") { + field(INPA, "KM36:TST:LS:Z10:UB_S1") + field(INPB, "KM36:TST:LS:Z10:P_S1") + field(INPC, "KM36:TST:LS:Z10:I_S1") + field(INPD, "KM36:TST:LS:Z10:D_S1") + field(INPE, "KM36:TST:LS:Z10:MOUT_S1") + field(INPF, "KM36:TST:LS:Z10:RANGE_S1") + field(INPG, "KM36:TST:LS:Z10:INPUT_S1") + field(INPH, "KM36:TST:LS:Z10:RATE_S1") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(1,10) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z10:ALL1.PROC") +} + + + + + + + + + + + + + + +# This is included in lakeshore336.template +# This template is for the common functionality shared by all 4 outputs. +# +# There is some logic in this database to provide put_callback functionality +# for setting the temperature and waiting for it to be in range. The input +# sensor PV name used for the in-window calculation changes depending on +# the input sensor selected. In order for this to work it requires the following +# macros: +# +# INPUTA - Sensor 1 PV name +# INPUTB - Sensor 2 PV name +# INPUTC - Sensor 3 PV name +# INPUTD - Sensor 4 PV name +# INPUTD2 - Sensor D2 PV name +# INPUTD3 - Sensor D3 PV name +# INPUTD4 - Sensor D4 PV name +# INPUTD5 - Sensor D5 PV name +# TOLERANCE (optional - defaults to 1) +# +# The input link names must fit into a stringout record for this to work. +# The above link names default to a dummy record. + +################################################################ +# Read records +################################################################ + +## +## Record holding the output number +## +record(stringout, "KM36:TST:LS:OUTPUT2") { + field(DTYP, "Soft Channel") + field(VAL, "2") + field(PINI, "YES") +} + +## +## Read the setpoint temperature. +## +record(ai, "KM36:TST:LS:SETP2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getSETP(2) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the setpoint limit +## + +## +## Read the ramp parameter. This also populates the ramp status KM36:TST:LS:RAMPST2, +## +record(ai, "KM36:TST:LS:RAMP2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getRAMP(2,KM36:TST:LS:RAMPST2) serial1 0") + field(SCAN, "5 second") + field(PREC, "3") + field(EGU, "K/min") +} + +## +## Read the ramp status parameter. +## +## 0=off +## 1=on +## +record(bi, "KM36:TST:LS:RAMPST2") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Read the range parameter (the heater output power range). +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:RANGE2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRANGE(2) serial1 0") +} + +## +## Read the mode to use for outmode +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:OMMODE2") { +} + +## +## Read the manual output parameter. +## +record(ai, "KM36:TST:LS:MOUT2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getMOUT(2) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID P parameter. Pass the I and D records into the protocol to read those as well. +## +record(ai, "KM36:TST:LS:P2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getPID(2,KM36:TST:LS:I2,KM36:TST:LS:D2) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID I parameter. +## +record(ai, "KM36:TST:LS:I2") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the PID D parameter. +## +record(ai, "KM36:TST:LS:D2") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the mode to use for outmode. +## This also populates the OMI and OMP records. +## The mbbi strings and values are defined in the output specific templates. +## +record(mbbi, "KM36:TST:LS:OMM2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getOM(2,KM36:TST:LS:OMI2,KM36:TST:LS:OMP2) serial1 0") +} + +## +## Read the input to use for outmode +## +record(mbbi, "KM36:TST:LS:OMI2") { + field(DTYP, "Soft Channel") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") +} + +## +## Read the power up mode to use for outmode +## +record(mbbi, "KM36:TST:LS:OMP2") { + field(DTYP, "Soft Channel") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") +} + +################################################################ +# Write records +################################################################ + +## +## Set the setpoint temperature. +## +record(ao, "KM36:TST:LS:SETP_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Setpoint temperature") + field(OUT, "@ls336.proto setSETP(2) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:SETP_S2_BUSYSET.PROC") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +############################################################################### + +## +## A few records to support put_callback on the setpoint. We use the busy record. +## A temperature window is used. The temperature must be within +## the window, before the callback is done. +## + +record(dfanout, "KM36:TST:LS:SETP_S2_BUSYSET") +{ + field(VAL, "0") + field(OUTA, "KM36:TST:LS:IN_WINDOW2.VAL PP") + field(FLNK, "KM36:TST:LS:SETP_S2_BUSYSET2") +} +record(dfanout, "KM36:TST:LS:SETP_S2_BUSYSET2") +{ + field(VAL, "1") + field(OUTA, "KM36:TST:LS:SETP2.PROC PP") + field(OUTB, "KM36:TST:LS:SETP_S2_BUSY PP") + field(FLNK, "KM36:TST:LS:CALC_IN_WINDOW2") +} +record(busy, "KM36:TST:LS:SETP_S2_BUSY") +{ +} +record(calcout, "KM36:TST:LS:CALC_IN_WINDOW2") { + field(PINI, "YES") + field(INPA, "1") + field(INPB, "KM36:TST:LS:DUMMY2.VAL") + field(INPC, "KM36:TST:LS:SETP_S2.VAL") + field(CALC, "((B>=(C-A))&&(B<=(C+A)))?1:0") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:IN_WINDOW2.VAL PP") + field(DOPT, "Use CALC") + field(SCAN, "1 second") + field(PREC, "1") + info(autosaveFields, "A") + info(archive, "Monitor, 00:00:01, A B C VAL") +} +record(bo, "KM36:TST:LS:IN_WINDOW2") { + field(DESC, "Temperature In Window") + field(VAL, "0") + field(PINI, "YES") + field(OMSL, "supervisory") + field(ZNAM, "Not In Window") + field(ONAM, "In Window") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Set busy record 'done' when TIME_WINDOW2=1 +## +record(calcout, "KM36:TST:LS:CALC_BUSY_DONE2") { + field(INPA, "KM36:TST:LS:IN_WINDOW2.VAL CP") + field(CALC, "(A=1)?0:1") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:SETP_S2_BUSY.VAL PP") +} + +############################################################################### + +## +## Dummy record to use for input link name default +## +record(ai, "KM36:TST:LS:DUMMY2") { +} + +## +## Monitor KM36:TST:LS:OMI2 to determin which input sensor to use +## to deal with the callback. The below set of records automatically +## switch the input when the 'control input' is changed. They make +## use of the input sensor PV names passed into this template. +## +record(calcout, "KM36:TST:LS:SET_2_INPUTA") { + field(CALC, "A=1") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTA_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTA_LINK") { + field(VAL, "KM36:TST:LS:KRDG0.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTB") { + field(CALC, "A=2") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTB_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTB_LINK") { + field(VAL, "KM36:TST:LS:KRDG1.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTC") { + field(CALC, "A=3") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTC_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTC_LINK") { + field(VAL, "KM36:TST:LS:KRDG2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTD") { + field(CALC, "A=4") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTD_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTD_LINK") { + field(VAL, "KM36:TST:LS:KRDG3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTD2") { + field(CALC, "A=5") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTD2_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTD2_LINK") { + field(VAL, "KM36:TST:LS:KRDGD2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTD3") { + field(CALC, "A=6") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTD3_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTD3_LINK") { + field(VAL, "KM36:TST:LS:KRDGD3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTD4") { + field(CALC, "A=7") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTD4_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTD4_LINK") { + field(VAL, "KM36:TST:LS:KRDGD4.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_2_INPUTD5") { + field(CALC, "A=8") + field(INPA, "KM36:TST:LS:OMI2.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_2_INPUTD5_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_2_INPUTD5_LINK") { + field(VAL, "KM36:TST:LS:KRDGD5.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW2.INPB CA") +} + + + +## +## Set the range parameter. +## The strings are output specific and is defined in another file. +## +record(mbbo, "KM36:TST:LS:RANGE_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRANGE(2) serial1 0") + field(FLNK, "KM36:TST:LS:RANGE2.PROC CA") +} + +## +## Set the ramp rate parameter. +## +## This is the desired temperate increase/decrease rate +## per second when heating/cooling. +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp status, as well as the +## desired ramp. This is done automatically by reading the +## PV which holds the current ramp status. +## +record(ao, "KM36:TST:LS:RAMP_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMP(KM36:TST:LS:RAMPST2,2) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:RAMP2.PROC CA") + field(EGU, "K/min") +} + +## +## Set the ramp status parameter. +## +## 0=off +## 1=on +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp, as well as the +## desired ramp status. This is done automatically by reading the +## PV which holds the current ramp value. +## +record(bo, "KM36:TST:LS:RAMPST_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMPSTATUS(KM36:TST:LS:RAMP2,2) serial1 0") + field(FLNK, "KM36:TST:LS:RAMP2.PROC CA") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Set the manual output value. +## +record(ao, "KM36:TST:LS:MOUT_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setMOUT(2) serial1 0") + field(FLNK, "KM36:TST:LS:MOUT2.PROC CA") +} + +## +## Set the PID P parameter. +## +record(ao, "KM36:TST:LS:P_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setP(2,KM36:TST:LS:I2,KM36:TST:LS:D2) serial1 0") + field(FLNK, "KM36:TST:LS:P2.PROC CA") +} + +## +## Set the PID I parameter. +## +record(ao, "KM36:TST:LS:I_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setI(KM36:TST:LS:P2,2,KM36:TST:LS:D2) serial1 0") + field(FLNK, "KM36:TST:LS:P2.PROC CA") +} + +## +## Set the PID D parameter. +## +record(ao, "KM36:TST:LS:D_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setD(KM36:TST:LS:P2,KM36:TST:LS:I2,2) serial1 0") + field(FLNK, "KM36:TST:LS:P2.PROC CA") +} + +## +## Set the mode to use for outmode +## The strings are output specific. This is defined in another file. +## +record(mbbo, "KM36:TST:LS:OMM_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(OUT, "@ls336.proto setOM(2,KM36:TST:LS:OMI2,KM36:TST:LS:OMP2) serial1 0") + field(FLNK, "KM36:TST:LS:OMM2.PROC CA") +} + +## +## Set the input to use for outmode +## +record(mbbo, "KM36:TST:LS:OMI_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(OUT, "@ls336.proto setOMI(2,KM36:TST:LS:OMM2,KM36:TST:LS:OMP2) serial1 0") + field(FLNK, "KM36:TST:LS:OMM2.PROC CA") +} + +## +## Set the power up mode to use for outmode +## +record(mbbo, "KM36:TST:LS:OMP_S2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") + field(OUT, "@ls336.proto setOMP(2,KM36:TST:LS:OMM2,KM36:TST:LS:OMI2) serial1 0") + field(FLNK, "KM36:TST:LS:OMM2.PROC CA") +} + +## +## Set the type of tuning mode +## +record(mbbo, "KM36:TST:LS:TUNEMODE_S2") { + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "P Only") + field(ZRVL, "0") + field(ONST, "P and I") + field(ONVL, "1") + field(TWST, "P, I and D") + field(TWVL, "2") +} + + +## +## Start the tuning process +## +record(ao, "KM36:TST:LS:TUNESTART2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Start the auto tuning") + field(OUT, "@ls336.proto setATUNE(2,KM36:TST:LS:TUNEMODE_S2) serial1 0") +} + + +## +## Read all ZONE settings +## +record(seq, "KM36:TST:LS:Z:READ2") { + field(DESC, "Read Output 2 ZONE") + field(DOL1, "1") + field(DLY1, "0.1") + field(LNK1, "KM36:TST:LS:Z1:ALL2.PROC") + field(DOL2, "1") + field(DLY2, "0.1") + field(LNK2, "KM36:TST:LS:Z2:ALL2.PROC") + field(DOL3, "1") + field(DLY3, "0.1") + field(LNK3, "KM36:TST:LS:Z3:ALL2.PROC") + field(DOL4, "1") + field(DLY4, "0.1") + field(LNK4, "KM36:TST:LS:Z4:ALL2.PROC") + field(DOL5, "1") + field(DLY5, "0.1") + field(LNK5, "KM36:TST:LS:Z5:ALL2.PROC") + field(DOL6, "1") + field(DLY6, "0.1") + field(LNK6, "KM36:TST:LS:Z6:ALL2.PROC") + field(DOL7, "1") + field(DLY7, "0.1") + field(LNK7, "KM36:TST:LS:Z7:ALL2.PROC") + field(DOL8, "1") + field(DLY8, "0.1") + field(LNK8, "KM36:TST:LS:Z8:ALL2.PROC") + field(DOL9, "1") + field(DLY9, "0.1") + field(LNK9, "KM36:TST:LS:Z9:ALL2.PROC") + field(DOLA, "1") + field(DLYA, "0.1") + field(LNKA, "KM36:TST:LS:Z10:ALL2.PROC") + field(PINI, "YES") +} + +############################################### +# This is included in lakeshore336.template +# This template is for outputs 1 and 2, which can provide heater power. + +################################################################ +# Read records +################################################################ + +## +## Read the heater output value. +## +record(ai, "KM36:TST:LS:HTR2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getHTR(2) serial1 0") + field(SCAN, "5 second") + field(PREC, "1") + field(EGU, "%") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Define the strings and values for this record. +## +record(mbbi, "KM36:TST:LS:RANGE2") { + field(ZRST, "Off") + field(ONST, "Range1/Low") + field(TWST, "Range2/Medium") + field(THST, "Range3/High") + field(FRST, "Range4") + field(FVST, "Range5") +} + +## +## Define the strings and values for this record. +## +record(mbbi, "KM36:TST:LS:OMM2") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:RANGE_S2") { + field(ZRST, "Off") + field(ONST, "Range1/Low") + field(TWST, "Range2/Medium") + field(THST, "Range3/High") + field(FRST, "Range4") + field(FVST, "Range5") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:OMM_S2") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") +} + +## +## Read the heater status +## +record(longin, "KM36:TST:LS:HTRST2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(SCAN, "5 second") + field(INP, "@ls336.proto getHTRST(D5) serial1 0") + field(FLNK, "KM36:TST:LS:HTRST2_CALC") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Cache the heater status because this is cleared on a read on the controller. +## +record(calcout, "KM36:TST:LS:HTRST2_CALC") { + field(INPA, "KM36:TST:LS:HTRST2.VAL") + field(CALC, "A!=0?A:0") + field(DOPT, "Use CALC") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:HTRST2_CACHE.RVAL PP") +} +record(mbbi, "KM36:TST:LS:HTRST2_CACHE") { + field(DESC, "Cached HTRST") + field(DTYP, "Raw Soft Channel") + field(ZRST, "No Error") + field(ZRVL, "0") + field(ONST, "Open Load") + field(ONVL, "1") + field(TWST, "Short/Compliance") + field(TWVL, "2") + field(VAL, "0") + field(PINI, "YES") + field(ONSV, "MAJOR") + field(TWSV, "MAJOR") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Provide record to reset the cached value +## +record(bo, "KM36:TST:LS:HTRST2_RESET") { + field(DESC, "Reset Cached HTRST") + field(VAL, "0") + field(OUT, "KM36:TST:LS:HTRST2_CACHE.RVAL PP") +} + +############################################### +# Add in ZONE support +############################################### + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z1:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,1) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z1:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z1:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z1:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P2.PROC") +} +record(ai, "KM36:TST:LS:Z1:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z1:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I2.PROC") +} +record(ai, "KM36:TST:LS:Z1:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z1:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D2.PROC") +} +record(ai, "KM36:TST:LS:Z1:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z1:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z1:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z1:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:RANGE2") { + field(INP, "KM36:TST:LS:Z1:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z1:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z1:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:INPUT2") { + field(INP, "KM36:TST:LS:Z1:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z1:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z1:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z1:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z1:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z1:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z1:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:P2.VAL") + field(OUTA, "KM36:TST:LS:Z1:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:I2.VAL") + field(OUTA, "KM36:TST:LS:Z1:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:D2.VAL") + field(OUTA, "KM36:TST:LS:Z1:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z1:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z1:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z1:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z1:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z1:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z1:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z1:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z1:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z1:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z1:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z1:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z1:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z1:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z1:SET2") { + field(INPA, "KM36:TST:LS:Z1:UB_S2") + field(INPB, "KM36:TST:LS:Z1:P_S2") + field(INPC, "KM36:TST:LS:Z1:I_S2") + field(INPD, "KM36:TST:LS:Z1:D_S2") + field(INPE, "KM36:TST:LS:Z1:MOUT_S2") + field(INPF, "KM36:TST:LS:Z1:RANGE_S2") + field(INPG, "KM36:TST:LS:Z1:INPUT_S2") + field(INPH, "KM36:TST:LS:Z1:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,1) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z1:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P2.PROC") +} +record(ai, "KM36:TST:LS:Z2:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I2.PROC") +} +record(ai, "KM36:TST:LS:Z2:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D2.PROC") +} +record(ai, "KM36:TST:LS:Z2:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE2") { + field(INP, "KM36:TST:LS:Z2:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT2") { + field(INP, "KM36:TST:LS:Z2:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P2.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I2.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D2.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET2") { + field(INPA, "KM36:TST:LS:Z2:UB_S2") + field(INPB, "KM36:TST:LS:Z2:P_S2") + field(INPC, "KM36:TST:LS:Z2:I_S2") + field(INPD, "KM36:TST:LS:Z2:D_S2") + field(INPE, "KM36:TST:LS:Z2:MOUT_S2") + field(INPF, "KM36:TST:LS:Z2:RANGE_S2") + field(INPG, "KM36:TST:LS:Z2:INPUT_S2") + field(INPH, "KM36:TST:LS:Z2:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P2.PROC") +} +record(ai, "KM36:TST:LS:Z2:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I2.PROC") +} +record(ai, "KM36:TST:LS:Z2:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D2.PROC") +} +record(ai, "KM36:TST:LS:Z2:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE2") { + field(INP, "KM36:TST:LS:Z2:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT2") { + field(INP, "KM36:TST:LS:Z2:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P2.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I2.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D2.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET2") { + field(INPA, "KM36:TST:LS:Z2:UB_S2") + field(INPB, "KM36:TST:LS:Z2:P_S2") + field(INPC, "KM36:TST:LS:Z2:I_S2") + field(INPD, "KM36:TST:LS:Z2:D_S2") + field(INPE, "KM36:TST:LS:Z2:MOUT_S2") + field(INPF, "KM36:TST:LS:Z2:RANGE_S2") + field(INPG, "KM36:TST:LS:Z2:INPUT_S2") + field(INPH, "KM36:TST:LS:Z2:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z3:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,3) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z3:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z3:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z3:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P2.PROC") +} +record(ai, "KM36:TST:LS:Z3:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z3:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I2.PROC") +} +record(ai, "KM36:TST:LS:Z3:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z3:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D2.PROC") +} +record(ai, "KM36:TST:LS:Z3:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z3:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z3:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z3:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:RANGE2") { + field(INP, "KM36:TST:LS:Z3:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z3:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z3:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:INPUT2") { + field(INP, "KM36:TST:LS:Z3:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z3:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z3:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z3:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z3:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z3:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z3:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:P2.VAL") + field(OUTA, "KM36:TST:LS:Z3:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:I2.VAL") + field(OUTA, "KM36:TST:LS:Z3:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:D2.VAL") + field(OUTA, "KM36:TST:LS:Z3:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z3:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z3:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z3:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z3:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z3:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z3:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z3:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z3:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z3:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z3:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z3:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z3:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z3:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z3:SET2") { + field(INPA, "KM36:TST:LS:Z3:UB_S2") + field(INPB, "KM36:TST:LS:Z3:P_S2") + field(INPC, "KM36:TST:LS:Z3:I_S2") + field(INPD, "KM36:TST:LS:Z3:D_S2") + field(INPE, "KM36:TST:LS:Z3:MOUT_S2") + field(INPF, "KM36:TST:LS:Z3:RANGE_S2") + field(INPG, "KM36:TST:LS:Z3:INPUT_S2") + field(INPH, "KM36:TST:LS:Z3:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,3) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z3:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z4:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,4) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z4:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z4:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z4:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P2.PROC") +} +record(ai, "KM36:TST:LS:Z4:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z4:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I2.PROC") +} +record(ai, "KM36:TST:LS:Z4:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z4:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D2.PROC") +} +record(ai, "KM36:TST:LS:Z4:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z4:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z4:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z4:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:RANGE2") { + field(INP, "KM36:TST:LS:Z4:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z4:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z4:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:INPUT2") { + field(INP, "KM36:TST:LS:Z4:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z4:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z4:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z4:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z4:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z4:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z4:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:P2.VAL") + field(OUTA, "KM36:TST:LS:Z4:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:I2.VAL") + field(OUTA, "KM36:TST:LS:Z4:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:D2.VAL") + field(OUTA, "KM36:TST:LS:Z4:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z4:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z4:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z4:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z4:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z4:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z4:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z4:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z4:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z4:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z4:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z4:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z4:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z4:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z4:SET2") { + field(INPA, "KM36:TST:LS:Z4:UB_S2") + field(INPB, "KM36:TST:LS:Z4:P_S2") + field(INPC, "KM36:TST:LS:Z4:I_S2") + field(INPD, "KM36:TST:LS:Z4:D_S2") + field(INPE, "KM36:TST:LS:Z4:MOUT_S2") + field(INPF, "KM36:TST:LS:Z4:RANGE_S2") + field(INPG, "KM36:TST:LS:Z4:INPUT_S2") + field(INPH, "KM36:TST:LS:Z4:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,4) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z4:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z5:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,5) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z5:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z5:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z5:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P2.PROC") +} +record(ai, "KM36:TST:LS:Z5:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z5:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I2.PROC") +} +record(ai, "KM36:TST:LS:Z5:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z5:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D2.PROC") +} +record(ai, "KM36:TST:LS:Z5:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z5:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z5:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z5:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:RANGE2") { + field(INP, "KM36:TST:LS:Z5:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z5:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z5:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:INPUT2") { + field(INP, "KM36:TST:LS:Z5:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z5:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z5:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z5:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z5:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z5:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z5:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:P2.VAL") + field(OUTA, "KM36:TST:LS:Z5:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:I2.VAL") + field(OUTA, "KM36:TST:LS:Z5:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:D2.VAL") + field(OUTA, "KM36:TST:LS:Z5:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z5:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z5:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z5:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z5:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z5:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z5:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z5:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z5:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z5:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z5:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z5:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z5:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z5:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z5:SET2") { + field(INPA, "KM36:TST:LS:Z5:UB_S2") + field(INPB, "KM36:TST:LS:Z5:P_S2") + field(INPC, "KM36:TST:LS:Z5:I_S2") + field(INPD, "KM36:TST:LS:Z5:D_S2") + field(INPE, "KM36:TST:LS:Z5:MOUT_S2") + field(INPF, "KM36:TST:LS:Z5:RANGE_S2") + field(INPG, "KM36:TST:LS:Z5:INPUT_S2") + field(INPH, "KM36:TST:LS:Z5:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,5) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z5:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z6:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,6) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z6:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z6:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z6:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P2.PROC") +} +record(ai, "KM36:TST:LS:Z6:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z6:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I2.PROC") +} +record(ai, "KM36:TST:LS:Z6:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z6:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D2.PROC") +} +record(ai, "KM36:TST:LS:Z6:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z6:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z6:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z6:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:RANGE2") { + field(INP, "KM36:TST:LS:Z6:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z6:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z6:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:INPUT2") { + field(INP, "KM36:TST:LS:Z6:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z6:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z6:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z6:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z6:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z6:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z6:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:P2.VAL") + field(OUTA, "KM36:TST:LS:Z6:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:I2.VAL") + field(OUTA, "KM36:TST:LS:Z6:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:D2.VAL") + field(OUTA, "KM36:TST:LS:Z6:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z6:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z6:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z6:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z6:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z6:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z6:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z6:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z6:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z6:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z6:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z6:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z6:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z6:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z6:SET2") { + field(INPA, "KM36:TST:LS:Z6:UB_S2") + field(INPB, "KM36:TST:LS:Z6:P_S2") + field(INPC, "KM36:TST:LS:Z6:I_S2") + field(INPD, "KM36:TST:LS:Z6:D_S2") + field(INPE, "KM36:TST:LS:Z6:MOUT_S2") + field(INPF, "KM36:TST:LS:Z6:RANGE_S2") + field(INPG, "KM36:TST:LS:Z6:INPUT_S2") + field(INPH, "KM36:TST:LS:Z6:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,6) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z6:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z7:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,7) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z7:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z7:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z7:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P2.PROC") +} +record(ai, "KM36:TST:LS:Z7:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z7:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I2.PROC") +} +record(ai, "KM36:TST:LS:Z7:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z7:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D2.PROC") +} +record(ai, "KM36:TST:LS:Z7:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z7:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z7:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z7:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:RANGE2") { + field(INP, "KM36:TST:LS:Z7:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z7:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z7:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:INPUT2") { + field(INP, "KM36:TST:LS:Z7:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z7:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z7:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z7:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z7:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z7:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z7:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:P2.VAL") + field(OUTA, "KM36:TST:LS:Z7:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:I2.VAL") + field(OUTA, "KM36:TST:LS:Z7:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:D2.VAL") + field(OUTA, "KM36:TST:LS:Z7:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z7:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z7:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z7:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z7:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z7:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z7:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z7:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z7:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z7:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z7:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z7:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z7:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z7:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z7:SET2") { + field(INPA, "KM36:TST:LS:Z7:UB_S2") + field(INPB, "KM36:TST:LS:Z7:P_S2") + field(INPC, "KM36:TST:LS:Z7:I_S2") + field(INPD, "KM36:TST:LS:Z7:D_S2") + field(INPE, "KM36:TST:LS:Z7:MOUT_S2") + field(INPF, "KM36:TST:LS:Z7:RANGE_S2") + field(INPG, "KM36:TST:LS:Z7:INPUT_S2") + field(INPH, "KM36:TST:LS:Z7:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,7) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z7:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z8:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,8) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z8:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z8:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z8:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P2.PROC") +} +record(ai, "KM36:TST:LS:Z8:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z8:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I2.PROC") +} +record(ai, "KM36:TST:LS:Z8:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z8:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D2.PROC") +} +record(ai, "KM36:TST:LS:Z8:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z8:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z8:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z8:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:RANGE2") { + field(INP, "KM36:TST:LS:Z8:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z8:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z8:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:INPUT2") { + field(INP, "KM36:TST:LS:Z8:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z8:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z8:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z8:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z8:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z8:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z8:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:P2.VAL") + field(OUTA, "KM36:TST:LS:Z8:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:I2.VAL") + field(OUTA, "KM36:TST:LS:Z8:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:D2.VAL") + field(OUTA, "KM36:TST:LS:Z8:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z8:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z8:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z8:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z8:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z8:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z8:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z8:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z8:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z8:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z8:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z8:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z8:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z8:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z8:SET2") { + field(INPA, "KM36:TST:LS:Z8:UB_S2") + field(INPB, "KM36:TST:LS:Z8:P_S2") + field(INPC, "KM36:TST:LS:Z8:I_S2") + field(INPD, "KM36:TST:LS:Z8:D_S2") + field(INPE, "KM36:TST:LS:Z8:MOUT_S2") + field(INPF, "KM36:TST:LS:Z8:RANGE_S2") + field(INPG, "KM36:TST:LS:Z8:INPUT_S2") + field(INPH, "KM36:TST:LS:Z8:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,8) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z8:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z9:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,9) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z9:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z9:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z9:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P2.PROC") +} +record(ai, "KM36:TST:LS:Z9:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z9:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I2.PROC") +} +record(ai, "KM36:TST:LS:Z9:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z9:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D2.PROC") +} +record(ai, "KM36:TST:LS:Z9:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z9:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z9:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z9:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:RANGE2") { + field(INP, "KM36:TST:LS:Z9:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z9:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z9:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:INPUT2") { + field(INP, "KM36:TST:LS:Z9:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z9:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z9:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z9:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z9:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z9:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z9:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:P2.VAL") + field(OUTA, "KM36:TST:LS:Z9:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:I2.VAL") + field(OUTA, "KM36:TST:LS:Z9:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:D2.VAL") + field(OUTA, "KM36:TST:LS:Z9:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z9:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z9:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z9:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z9:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z9:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z9:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z9:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z9:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z9:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z9:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z9:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z9:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z9:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z9:SET2") { + field(INPA, "KM36:TST:LS:Z9:UB_S2") + field(INPB, "KM36:TST:LS:Z9:P_S2") + field(INPC, "KM36:TST:LS:Z9:I_S2") + field(INPD, "KM36:TST:LS:Z9:D_S2") + field(INPE, "KM36:TST:LS:Z9:MOUT_S2") + field(INPF, "KM36:TST:LS:Z9:RANGE_S2") + field(INPG, "KM36:TST:LS:Z9:INPUT_S2") + field(INPH, "KM36:TST:LS:Z9:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,9) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z9:ALL2.PROC") +} + + + + + + + + + + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z10:ALL2") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(2,10) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB2:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z10:UB2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB2.PROC") +} +record(ai, "KM36:TST:LS:Z10:UB2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:UB2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P2:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z10:P2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P2.PROC") +} +record(ai, "KM36:TST:LS:Z10:P2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:P2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I2:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z10:I2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I2.PROC") +} +record(ai, "KM36:TST:LS:Z10:I2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:I2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D2:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z10:D2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D2.PROC") +} +record(ai, "KM36:TST:LS:Z10:D2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:D2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT2:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z10:MOUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT2.PROC") +} +record(ai, "KM36:TST:LS:Z10:MOUT2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:MOUT2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE2:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z10:RANGE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE2.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:RANGE2") { + field(INP, "KM36:TST:LS:Z10:RANGE2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z10:INPUT2:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z10:INPUT2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INPUT2.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:INPUT2") { + field(INP, "KM36:TST:LS:Z10:INPUT2:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z10:RATE2:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z10:RATE2:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL2.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RATE2.PROC") +} +record(ai, "KM36:TST:LS:Z10:RATE2") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:RATE2:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INITCALC2.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z10:INITCALC2") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z10:INITUB2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITUB2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:UB2.VAL") + field(OUTA, "KM36:TST:LS:Z10:UB_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITP2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITP2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:P2.VAL") + field(OUTA, "KM36:TST:LS:Z10:P_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITI2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITI2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:I2.VAL") + field(OUTA, "KM36:TST:LS:Z10:I_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITD2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITD2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:D2.VAL") + field(OUTA, "KM36:TST:LS:Z10:D_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITMOUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITMOUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:MOUT2.VAL") + field(OUTA, "KM36:TST:LS:Z10:MOUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRANGE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRANGE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RANGE2.VAL") + field(OUTA, "KM36:TST:LS:Z10:RANGE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITINPUT2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITINPUT2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:INPUT2.VAL") + field(OUTA, "KM36:TST:LS:Z10:INPUT_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRATE2.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRATE2") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RATE2.VAL") + field(OUTA, "KM36:TST:LS:Z10:RATE_S2.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITCOUNT2.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITCOUNT2") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z10:INITCALC2.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z10:UB_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z10:P_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z10:I_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z10:D_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z10:MOUT_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z10:RANGE_S2") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z10:INPUT_S2") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z10:RATE_S2") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z10:SET2") { + field(INPA, "KM36:TST:LS:Z10:UB_S2") + field(INPB, "KM36:TST:LS:Z10:P_S2") + field(INPC, "KM36:TST:LS:Z10:I_S2") + field(INPD, "KM36:TST:LS:Z10:D_S2") + field(INPE, "KM36:TST:LS:Z10:MOUT_S2") + field(INPF, "KM36:TST:LS:Z10:RANGE_S2") + field(INPG, "KM36:TST:LS:Z10:INPUT_S2") + field(INPH, "KM36:TST:LS:Z10:RATE_S2") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(2,10) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z10:ALL2.PROC") +} + + + + + + + + + + + + + + +# This is included in lakeshore336.template +# This template is for the common functionality shared by all 4 outputs. +# +# There is some logic in this database to provide put_callback functionality +# for setting the temperature and waiting for it to be in range. The input +# sensor PV name used for the in-window calculation changes depending on +# the input sensor selected. In order for this to work it requires the following +# macros: +# +# INPUTA - Sensor 1 PV name +# INPUTB - Sensor 2 PV name +# INPUTC - Sensor 3 PV name +# INPUTD - Sensor 4 PV name +# INPUTD2 - Sensor D2 PV name +# INPUTD3 - Sensor D3 PV name +# INPUTD4 - Sensor D4 PV name +# INPUTD5 - Sensor D5 PV name +# TOLERANCE (optional - defaults to 1) +# +# The input link names must fit into a stringout record for this to work. +# The above link names default to a dummy record. + +################################################################ +# Read records +################################################################ + +## +## Record holding the output number +## +record(stringout, "KM36:TST:LS:OUTPUT3") { + field(DTYP, "Soft Channel") + field(VAL, "3") + field(PINI, "YES") +} + +## +## Read the setpoint temperature. +## +record(ai, "KM36:TST:LS:SETP3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getSETP(3) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the setpoint limit +## + +## +## Read the ramp parameter. This also populates the ramp status KM36:TST:LS:RAMPST3, +## +record(ai, "KM36:TST:LS:RAMP3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getRAMP(3,KM36:TST:LS:RAMPST3) serial1 0") + field(SCAN, "5 second") + field(PREC, "3") + field(EGU, "K/min") +} + +## +## Read the ramp status parameter. +## +## 0=off +## 1=on +## +record(bi, "KM36:TST:LS:RAMPST3") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Read the range parameter (the heater output power range). +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:RANGE3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRANGE(3) serial1 0") +} + +## +## Read the mode to use for outmode +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:OMMODE3") { +} + +## +## Read the manual output parameter. +## +record(ai, "KM36:TST:LS:MOUT3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getMOUT(3) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID P parameter. Pass the I and D records into the protocol to read those as well. +## +record(ai, "KM36:TST:LS:P3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getPID(3,KM36:TST:LS:I3,KM36:TST:LS:D3) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID I parameter. +## +record(ai, "KM36:TST:LS:I3") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the PID D parameter. +## +record(ai, "KM36:TST:LS:D3") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the mode to use for outmode. +## This also populates the OMI and OMP records. +## The mbbi strings and values are defined in the output specific templates. +## +record(mbbi, "KM36:TST:LS:OMM3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getOM(3,KM36:TST:LS:OMI3,KM36:TST:LS:OMP3) serial1 0") +} + +## +## Read the input to use for outmode +## +record(mbbi, "KM36:TST:LS:OMI3") { + field(DTYP, "Soft Channel") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") +} + +## +## Read the power up mode to use for outmode +## +record(mbbi, "KM36:TST:LS:OMP3") { + field(DTYP, "Soft Channel") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") +} + +################################################################ +# Write records +################################################################ + +## +## Set the setpoint temperature. +## +record(ao, "KM36:TST:LS:SETP_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Setpoint temperature") + field(OUT, "@ls336.proto setSETP(3) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:SETP_S3_BUSYSET.PROC") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +############################################################################### + +## +## A few records to support put_callback on the setpoint. We use the busy record. +## A temperature window is used. The temperature must be within +## the window, before the callback is done. +## + +record(dfanout, "KM36:TST:LS:SETP_S3_BUSYSET") +{ + field(VAL, "0") + field(OUTA, "KM36:TST:LS:IN_WINDOW3.VAL PP") + field(FLNK, "KM36:TST:LS:SETP_S3_BUSYSET2") +} +record(dfanout, "KM36:TST:LS:SETP_S3_BUSYSET2") +{ + field(VAL, "1") + field(OUTA, "KM36:TST:LS:SETP3.PROC PP") + field(OUTB, "KM36:TST:LS:SETP_S3_BUSY PP") + field(FLNK, "KM36:TST:LS:CALC_IN_WINDOW3") +} +record(busy, "KM36:TST:LS:SETP_S3_BUSY") +{ +} +record(calcout, "KM36:TST:LS:CALC_IN_WINDOW3") { + field(PINI, "YES") + field(INPA, "1") + field(INPB, "KM36:TST:LS:DUMMY3.VAL") + field(INPC, "KM36:TST:LS:SETP_S3.VAL") + field(CALC, "((B>=(C-A))&&(B<=(C+A)))?1:0") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:IN_WINDOW3.VAL PP") + field(DOPT, "Use CALC") + field(SCAN, "1 second") + field(PREC, "1") + info(autosaveFields, "A") + info(archive, "Monitor, 00:00:01, A B C VAL") +} +record(bo, "KM36:TST:LS:IN_WINDOW3") { + field(DESC, "Temperature In Window") + field(VAL, "0") + field(PINI, "YES") + field(OMSL, "supervisory") + field(ZNAM, "Not In Window") + field(ONAM, "In Window") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Set busy record 'done' when TIME_WINDOW3=1 +## +record(calcout, "KM36:TST:LS:CALC_BUSY_DONE3") { + field(INPA, "KM36:TST:LS:IN_WINDOW3.VAL CP") + field(CALC, "(A=1)?0:1") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:SETP_S3_BUSY.VAL PP") +} + +############################################################################### + +## +## Dummy record to use for input link name default +## +record(ai, "KM36:TST:LS:DUMMY3") { +} + +## +## Monitor KM36:TST:LS:OMI3 to determin which input sensor to use +## to deal with the callback. The below set of records automatically +## switch the input when the 'control input' is changed. They make +## use of the input sensor PV names passed into this template. +## +record(calcout, "KM36:TST:LS:SET_3_INPUTA") { + field(CALC, "A=1") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTA_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTA_LINK") { + field(VAL, "KM36:TST:LS:KRDG0.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTB") { + field(CALC, "A=2") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTB_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTB_LINK") { + field(VAL, "KM36:TST:LS:KRDG1.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTC") { + field(CALC, "A=3") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTC_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTC_LINK") { + field(VAL, "KM36:TST:LS:KRDG2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTD") { + field(CALC, "A=4") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTD_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTD_LINK") { + field(VAL, "KM36:TST:LS:KRDG3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTD2") { + field(CALC, "A=5") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTD2_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTD2_LINK") { + field(VAL, "KM36:TST:LS:KRDGD2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTD3") { + field(CALC, "A=6") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTD3_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTD3_LINK") { + field(VAL, "KM36:TST:LS:KRDGD3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTD4") { + field(CALC, "A=7") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTD4_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTD4_LINK") { + field(VAL, "KM36:TST:LS:KRDGD4.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_3_INPUTD5") { + field(CALC, "A=8") + field(INPA, "KM36:TST:LS:OMI3.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_3_INPUTD5_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_3_INPUTD5_LINK") { + field(VAL, "KM36:TST:LS:KRDGD5.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW3.INPB CA") +} + + + +## +## Set the range parameter. +## The strings are output specific and is defined in another file. +## +record(mbbo, "KM36:TST:LS:RANGE_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRANGE(3) serial1 0") + field(FLNK, "KM36:TST:LS:RANGE3.PROC CA") +} + +## +## Set the ramp rate parameter. +## +## This is the desired temperate increase/decrease rate +## per second when heating/cooling. +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp status, as well as the +## desired ramp. This is done automatically by reading the +## PV which holds the current ramp status. +## +record(ao, "KM36:TST:LS:RAMP_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMP(KM36:TST:LS:RAMPST3,3) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:RAMP3.PROC CA") + field(EGU, "K/min") +} + +## +## Set the ramp status parameter. +## +## 0=off +## 1=on +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp, as well as the +## desired ramp status. This is done automatically by reading the +## PV which holds the current ramp value. +## +record(bo, "KM36:TST:LS:RAMPST_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMPSTATUS(KM36:TST:LS:RAMP3,3) serial1 0") + field(FLNK, "KM36:TST:LS:RAMP3.PROC CA") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Set the manual output value. +## +record(ao, "KM36:TST:LS:MOUT_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setMOUT(3) serial1 0") + field(FLNK, "KM36:TST:LS:MOUT3.PROC CA") +} + +## +## Set the PID P parameter. +## +record(ao, "KM36:TST:LS:P_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setP(3,KM36:TST:LS:I3,KM36:TST:LS:D3) serial1 0") + field(FLNK, "KM36:TST:LS:P3.PROC CA") +} + +## +## Set the PID I parameter. +## +record(ao, "KM36:TST:LS:I_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setI(KM36:TST:LS:P3,3,KM36:TST:LS:D3) serial1 0") + field(FLNK, "KM36:TST:LS:P3.PROC CA") +} + +## +## Set the PID D parameter. +## +record(ao, "KM36:TST:LS:D_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setD(KM36:TST:LS:P3,KM36:TST:LS:I3,3) serial1 0") + field(FLNK, "KM36:TST:LS:P3.PROC CA") +} + +## +## Set the mode to use for outmode +## The strings are output specific. This is defined in another file. +## +record(mbbo, "KM36:TST:LS:OMM_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(OUT, "@ls336.proto setOM(3,KM36:TST:LS:OMI3,KM36:TST:LS:OMP3) serial1 0") + field(FLNK, "KM36:TST:LS:OMM3.PROC CA") +} + +## +## Set the input to use for outmode +## +record(mbbo, "KM36:TST:LS:OMI_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(OUT, "@ls336.proto setOMI(3,KM36:TST:LS:OMM3,KM36:TST:LS:OMP3) serial1 0") + field(FLNK, "KM36:TST:LS:OMM3.PROC CA") +} + +## +## Set the power up mode to use for outmode +## +record(mbbo, "KM36:TST:LS:OMP_S3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") + field(OUT, "@ls336.proto setOMP(3,KM36:TST:LS:OMM3,KM36:TST:LS:OMI3) serial1 0") + field(FLNK, "KM36:TST:LS:OMM3.PROC CA") +} + +## +## Set the type of tuning mode +## +record(mbbo, "KM36:TST:LS:TUNEMODE_S3") { + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "P Only") + field(ZRVL, "0") + field(ONST, "P and I") + field(ONVL, "1") + field(TWST, "P, I and D") + field(TWVL, "2") +} + + +## +## Start the tuning process +## +record(ao, "KM36:TST:LS:TUNESTART3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Start the auto tuning") + field(OUT, "@ls336.proto setATUNE(3,KM36:TST:LS:TUNEMODE_S3) serial1 0") +} + + +## +## Read all ZONE settings +## +record(seq, "KM36:TST:LS:Z:READ3") { + field(DESC, "Read Output 3 ZONE") + field(DOL1, "1") + field(DLY1, "0.1") + field(LNK1, "KM36:TST:LS:Z1:ALL3.PROC") + field(DOL2, "1") + field(DLY2, "0.1") + field(LNK2, "KM36:TST:LS:Z2:ALL3.PROC") + field(DOL3, "1") + field(DLY3, "0.1") + field(LNK3, "KM36:TST:LS:Z3:ALL3.PROC") + field(DOL4, "1") + field(DLY4, "0.1") + field(LNK4, "KM36:TST:LS:Z4:ALL3.PROC") + field(DOL5, "1") + field(DLY5, "0.1") + field(LNK5, "KM36:TST:LS:Z5:ALL3.PROC") + field(DOL6, "1") + field(DLY6, "0.1") + field(LNK6, "KM36:TST:LS:Z6:ALL3.PROC") + field(DOL7, "1") + field(DLY7, "0.1") + field(LNK7, "KM36:TST:LS:Z7:ALL3.PROC") + field(DOL8, "1") + field(DLY8, "0.1") + field(LNK8, "KM36:TST:LS:Z8:ALL3.PROC") + field(DOL9, "1") + field(DLY9, "0.1") + field(LNK9, "KM36:TST:LS:Z9:ALL3.PROC") + field(DOLA, "1") + field(DLYA, "0.1") + field(LNKA, "KM36:TST:LS:Z10:ALL3.PROC") + field(PINI, "YES") +} + +############################################### +# This is included in lakeshore336.template +# This is for the analog outputs (3 and 4) + +## +## Read the analog output value. +## +record(ai, "KM36:TST:LS:AOUT3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getAOUT(3) serial1 0") + field(SCAN, "5 second") + field(PREC, "1") + field(EGU, "%") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Define the string/values for this record. +## +record(mbbi, "KM36:TST:LS:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") +} + +## +## Define the strings and values for this record. +## +record(mbbi, "KM36:TST:LS:OMM3") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") + field(FRST, "Monitor Out") + field(FVST, "Warmup Supply") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:OMM_S3") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") + field(FRST, "Monitor Out") + field(FVST, "Warmup Supply") +} + +############################################### +# Add in ZONE support +############################################### + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z1:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,1) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z1:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z1:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z1:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P3.PROC") +} +record(ai, "KM36:TST:LS:Z1:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z1:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I3.PROC") +} +record(ai, "KM36:TST:LS:Z1:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z1:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D3.PROC") +} +record(ai, "KM36:TST:LS:Z1:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z1:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z1:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z1:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:RANGE3") { + field(INP, "KM36:TST:LS:Z1:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z1:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z1:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:INPUT3") { + field(INP, "KM36:TST:LS:Z1:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z1:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z1:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z1:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z1:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z1:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z1:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:P3.VAL") + field(OUTA, "KM36:TST:LS:Z1:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:I3.VAL") + field(OUTA, "KM36:TST:LS:Z1:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:D3.VAL") + field(OUTA, "KM36:TST:LS:Z1:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z1:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z1:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z1:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z1:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z1:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z1:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z1:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z1:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z1:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z1:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z1:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z1:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z1:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z1:SET3") { + field(INPA, "KM36:TST:LS:Z1:UB_S3") + field(INPB, "KM36:TST:LS:Z1:P_S3") + field(INPC, "KM36:TST:LS:Z1:I_S3") + field(INPD, "KM36:TST:LS:Z1:D_S3") + field(INPE, "KM36:TST:LS:Z1:MOUT_S3") + field(INPF, "KM36:TST:LS:Z1:RANGE_S3") + field(INPG, "KM36:TST:LS:Z1:INPUT_S3") + field(INPH, "KM36:TST:LS:Z1:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,1) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z1:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z1:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z1:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P3.PROC") +} +record(ai, "KM36:TST:LS:Z2:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I3.PROC") +} +record(ai, "KM36:TST:LS:Z2:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D3.PROC") +} +record(ai, "KM36:TST:LS:Z2:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE3") { + field(INP, "KM36:TST:LS:Z2:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT3") { + field(INP, "KM36:TST:LS:Z2:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P3.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I3.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D3.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET3") { + field(INPA, "KM36:TST:LS:Z2:UB_S3") + field(INPB, "KM36:TST:LS:Z2:P_S3") + field(INPC, "KM36:TST:LS:Z2:I_S3") + field(INPD, "KM36:TST:LS:Z2:D_S3") + field(INPE, "KM36:TST:LS:Z2:MOUT_S3") + field(INPF, "KM36:TST:LS:Z2:RANGE_S3") + field(INPG, "KM36:TST:LS:Z2:INPUT_S3") + field(INPH, "KM36:TST:LS:Z2:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z2:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z2:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P3.PROC") +} +record(ai, "KM36:TST:LS:Z2:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I3.PROC") +} +record(ai, "KM36:TST:LS:Z2:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D3.PROC") +} +record(ai, "KM36:TST:LS:Z2:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE3") { + field(INP, "KM36:TST:LS:Z2:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT3") { + field(INP, "KM36:TST:LS:Z2:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P3.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I3.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D3.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET3") { + field(INPA, "KM36:TST:LS:Z2:UB_S3") + field(INPB, "KM36:TST:LS:Z2:P_S3") + field(INPC, "KM36:TST:LS:Z2:I_S3") + field(INPD, "KM36:TST:LS:Z2:D_S3") + field(INPE, "KM36:TST:LS:Z2:MOUT_S3") + field(INPF, "KM36:TST:LS:Z2:RANGE_S3") + field(INPG, "KM36:TST:LS:Z2:INPUT_S3") + field(INPH, "KM36:TST:LS:Z2:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z2:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z2:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z3:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,3) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z3:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z3:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z3:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P3.PROC") +} +record(ai, "KM36:TST:LS:Z3:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z3:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I3.PROC") +} +record(ai, "KM36:TST:LS:Z3:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z3:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D3.PROC") +} +record(ai, "KM36:TST:LS:Z3:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z3:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z3:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z3:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:RANGE3") { + field(INP, "KM36:TST:LS:Z3:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z3:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z3:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:INPUT3") { + field(INP, "KM36:TST:LS:Z3:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z3:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z3:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z3:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z3:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z3:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z3:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:P3.VAL") + field(OUTA, "KM36:TST:LS:Z3:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:I3.VAL") + field(OUTA, "KM36:TST:LS:Z3:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:D3.VAL") + field(OUTA, "KM36:TST:LS:Z3:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z3:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z3:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z3:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z3:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z3:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z3:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z3:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z3:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z3:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z3:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z3:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z3:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z3:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z3:SET3") { + field(INPA, "KM36:TST:LS:Z3:UB_S3") + field(INPB, "KM36:TST:LS:Z3:P_S3") + field(INPC, "KM36:TST:LS:Z3:I_S3") + field(INPD, "KM36:TST:LS:Z3:D_S3") + field(INPE, "KM36:TST:LS:Z3:MOUT_S3") + field(INPF, "KM36:TST:LS:Z3:RANGE_S3") + field(INPG, "KM36:TST:LS:Z3:INPUT_S3") + field(INPH, "KM36:TST:LS:Z3:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,3) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z3:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z3:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z3:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z4:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,4) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z4:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z4:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z4:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P3.PROC") +} +record(ai, "KM36:TST:LS:Z4:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z4:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I3.PROC") +} +record(ai, "KM36:TST:LS:Z4:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z4:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D3.PROC") +} +record(ai, "KM36:TST:LS:Z4:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z4:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z4:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z4:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:RANGE3") { + field(INP, "KM36:TST:LS:Z4:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z4:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z4:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:INPUT3") { + field(INP, "KM36:TST:LS:Z4:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z4:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z4:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z4:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z4:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z4:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z4:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:P3.VAL") + field(OUTA, "KM36:TST:LS:Z4:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:I3.VAL") + field(OUTA, "KM36:TST:LS:Z4:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:D3.VAL") + field(OUTA, "KM36:TST:LS:Z4:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z4:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z4:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z4:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z4:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z4:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z4:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z4:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z4:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z4:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z4:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z4:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z4:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z4:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z4:SET3") { + field(INPA, "KM36:TST:LS:Z4:UB_S3") + field(INPB, "KM36:TST:LS:Z4:P_S3") + field(INPC, "KM36:TST:LS:Z4:I_S3") + field(INPD, "KM36:TST:LS:Z4:D_S3") + field(INPE, "KM36:TST:LS:Z4:MOUT_S3") + field(INPF, "KM36:TST:LS:Z4:RANGE_S3") + field(INPG, "KM36:TST:LS:Z4:INPUT_S3") + field(INPH, "KM36:TST:LS:Z4:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,4) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z4:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z4:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z4:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z5:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,5) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z5:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z5:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z5:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P3.PROC") +} +record(ai, "KM36:TST:LS:Z5:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z5:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I3.PROC") +} +record(ai, "KM36:TST:LS:Z5:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z5:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D3.PROC") +} +record(ai, "KM36:TST:LS:Z5:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z5:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z5:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z5:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:RANGE3") { + field(INP, "KM36:TST:LS:Z5:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z5:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z5:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:INPUT3") { + field(INP, "KM36:TST:LS:Z5:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z5:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z5:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z5:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z5:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z5:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z5:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:P3.VAL") + field(OUTA, "KM36:TST:LS:Z5:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:I3.VAL") + field(OUTA, "KM36:TST:LS:Z5:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:D3.VAL") + field(OUTA, "KM36:TST:LS:Z5:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z5:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z5:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z5:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z5:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z5:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z5:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z5:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z5:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z5:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z5:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z5:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z5:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z5:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z5:SET3") { + field(INPA, "KM36:TST:LS:Z5:UB_S3") + field(INPB, "KM36:TST:LS:Z5:P_S3") + field(INPC, "KM36:TST:LS:Z5:I_S3") + field(INPD, "KM36:TST:LS:Z5:D_S3") + field(INPE, "KM36:TST:LS:Z5:MOUT_S3") + field(INPF, "KM36:TST:LS:Z5:RANGE_S3") + field(INPG, "KM36:TST:LS:Z5:INPUT_S3") + field(INPH, "KM36:TST:LS:Z5:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,5) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z5:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z5:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z5:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z6:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,6) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z6:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z6:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z6:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P3.PROC") +} +record(ai, "KM36:TST:LS:Z6:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z6:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I3.PROC") +} +record(ai, "KM36:TST:LS:Z6:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z6:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D3.PROC") +} +record(ai, "KM36:TST:LS:Z6:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z6:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z6:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z6:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:RANGE3") { + field(INP, "KM36:TST:LS:Z6:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z6:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z6:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:INPUT3") { + field(INP, "KM36:TST:LS:Z6:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z6:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z6:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z6:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z6:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z6:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z6:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:P3.VAL") + field(OUTA, "KM36:TST:LS:Z6:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:I3.VAL") + field(OUTA, "KM36:TST:LS:Z6:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:D3.VAL") + field(OUTA, "KM36:TST:LS:Z6:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z6:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z6:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z6:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z6:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z6:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z6:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z6:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z6:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z6:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z6:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z6:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z6:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z6:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z6:SET3") { + field(INPA, "KM36:TST:LS:Z6:UB_S3") + field(INPB, "KM36:TST:LS:Z6:P_S3") + field(INPC, "KM36:TST:LS:Z6:I_S3") + field(INPD, "KM36:TST:LS:Z6:D_S3") + field(INPE, "KM36:TST:LS:Z6:MOUT_S3") + field(INPF, "KM36:TST:LS:Z6:RANGE_S3") + field(INPG, "KM36:TST:LS:Z6:INPUT_S3") + field(INPH, "KM36:TST:LS:Z6:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,6) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z6:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z6:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z6:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z7:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,7) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z7:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z7:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z7:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P3.PROC") +} +record(ai, "KM36:TST:LS:Z7:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z7:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I3.PROC") +} +record(ai, "KM36:TST:LS:Z7:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z7:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D3.PROC") +} +record(ai, "KM36:TST:LS:Z7:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z7:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z7:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z7:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:RANGE3") { + field(INP, "KM36:TST:LS:Z7:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z7:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z7:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:INPUT3") { + field(INP, "KM36:TST:LS:Z7:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z7:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z7:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z7:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z7:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z7:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z7:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:P3.VAL") + field(OUTA, "KM36:TST:LS:Z7:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:I3.VAL") + field(OUTA, "KM36:TST:LS:Z7:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:D3.VAL") + field(OUTA, "KM36:TST:LS:Z7:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z7:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z7:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z7:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z7:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z7:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z7:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z7:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z7:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z7:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z7:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z7:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z7:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z7:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z7:SET3") { + field(INPA, "KM36:TST:LS:Z7:UB_S3") + field(INPB, "KM36:TST:LS:Z7:P_S3") + field(INPC, "KM36:TST:LS:Z7:I_S3") + field(INPD, "KM36:TST:LS:Z7:D_S3") + field(INPE, "KM36:TST:LS:Z7:MOUT_S3") + field(INPF, "KM36:TST:LS:Z7:RANGE_S3") + field(INPG, "KM36:TST:LS:Z7:INPUT_S3") + field(INPH, "KM36:TST:LS:Z7:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,7) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z7:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z7:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z7:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z8:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,8) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z8:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z8:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z8:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P3.PROC") +} +record(ai, "KM36:TST:LS:Z8:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z8:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I3.PROC") +} +record(ai, "KM36:TST:LS:Z8:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z8:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D3.PROC") +} +record(ai, "KM36:TST:LS:Z8:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z8:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z8:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z8:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:RANGE3") { + field(INP, "KM36:TST:LS:Z8:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z8:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z8:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:INPUT3") { + field(INP, "KM36:TST:LS:Z8:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z8:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z8:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z8:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z8:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z8:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z8:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:P3.VAL") + field(OUTA, "KM36:TST:LS:Z8:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:I3.VAL") + field(OUTA, "KM36:TST:LS:Z8:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:D3.VAL") + field(OUTA, "KM36:TST:LS:Z8:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z8:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z8:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z8:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z8:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z8:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z8:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z8:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z8:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z8:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z8:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z8:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z8:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z8:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z8:SET3") { + field(INPA, "KM36:TST:LS:Z8:UB_S3") + field(INPB, "KM36:TST:LS:Z8:P_S3") + field(INPC, "KM36:TST:LS:Z8:I_S3") + field(INPD, "KM36:TST:LS:Z8:D_S3") + field(INPE, "KM36:TST:LS:Z8:MOUT_S3") + field(INPF, "KM36:TST:LS:Z8:RANGE_S3") + field(INPG, "KM36:TST:LS:Z8:INPUT_S3") + field(INPH, "KM36:TST:LS:Z8:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,8) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z8:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z8:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z8:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z9:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,9) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z9:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z9:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z9:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P3.PROC") +} +record(ai, "KM36:TST:LS:Z9:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z9:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I3.PROC") +} +record(ai, "KM36:TST:LS:Z9:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z9:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D3.PROC") +} +record(ai, "KM36:TST:LS:Z9:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z9:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z9:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z9:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:RANGE3") { + field(INP, "KM36:TST:LS:Z9:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z9:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z9:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:INPUT3") { + field(INP, "KM36:TST:LS:Z9:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z9:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z9:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z9:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z9:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z9:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z9:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:P3.VAL") + field(OUTA, "KM36:TST:LS:Z9:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:I3.VAL") + field(OUTA, "KM36:TST:LS:Z9:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:D3.VAL") + field(OUTA, "KM36:TST:LS:Z9:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z9:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z9:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z9:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z9:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z9:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z9:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z9:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z9:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z9:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z9:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z9:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z9:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z9:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z9:SET3") { + field(INPA, "KM36:TST:LS:Z9:UB_S3") + field(INPB, "KM36:TST:LS:Z9:P_S3") + field(INPC, "KM36:TST:LS:Z9:I_S3") + field(INPD, "KM36:TST:LS:Z9:D_S3") + field(INPE, "KM36:TST:LS:Z9:MOUT_S3") + field(INPF, "KM36:TST:LS:Z9:RANGE_S3") + field(INPG, "KM36:TST:LS:Z9:INPUT_S3") + field(INPH, "KM36:TST:LS:Z9:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,9) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z9:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z9:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z9:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z10:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,10) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z10:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z10:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z10:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P3.PROC") +} +record(ai, "KM36:TST:LS:Z10:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z10:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I3.PROC") +} +record(ai, "KM36:TST:LS:Z10:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z10:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D3.PROC") +} +record(ai, "KM36:TST:LS:Z10:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z10:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z10:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z10:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:RANGE3") { + field(INP, "KM36:TST:LS:Z10:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z10:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z10:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:INPUT3") { + field(INP, "KM36:TST:LS:Z10:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z10:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z10:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z10:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z10:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z10:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z10:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:P3.VAL") + field(OUTA, "KM36:TST:LS:Z10:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:I3.VAL") + field(OUTA, "KM36:TST:LS:Z10:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:D3.VAL") + field(OUTA, "KM36:TST:LS:Z10:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z10:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z10:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z10:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z10:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z10:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z10:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z10:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z10:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z10:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z10:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z10:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z10:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z10:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z10:SET3") { + field(INPA, "KM36:TST:LS:Z10:UB_S3") + field(INPB, "KM36:TST:LS:Z10:P_S3") + field(INPC, "KM36:TST:LS:Z10:I_S3") + field(INPD, "KM36:TST:LS:Z10:D_S3") + field(INPE, "KM36:TST:LS:Z10:MOUT_S3") + field(INPF, "KM36:TST:LS:Z10:RANGE_S3") + field(INPG, "KM36:TST:LS:Z10:INPUT_S3") + field(INPH, "KM36:TST:LS:Z10:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,10) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z10:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z10:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z10:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This is included in lakeshore336.template +# This template is for the common functionality shared by all 4 outputs. +# +# There is some logic in this database to provide put_callback functionality +# for setting the temperature and waiting for it to be in range. The input +# sensor PV name used for the in-window calculation changes depending on +# the input sensor selected. In order for this to work it requires the following +# macros: +# +# INPUTA - Sensor 1 PV name +# INPUTB - Sensor 2 PV name +# INPUTC - Sensor 3 PV name +# INPUTD - Sensor 4 PV name +# INPUTD2 - Sensor D2 PV name +# INPUTD3 - Sensor D3 PV name +# INPUTD4 - Sensor D4 PV name +# INPUTD5 - Sensor D5 PV name +# TOLERANCE (optional - defaults to 1) +# +# The input link names must fit into a stringout record for this to work. +# The above link names default to a dummy record. + +################################################################ +# Read records +################################################################ + +## +## Record holding the output number +## +record(stringout, "KM36:TST:LS:OUTPUT4") { + field(DTYP, "Soft Channel") + field(VAL, "4") + field(PINI, "YES") +} + +## +## Read the setpoint temperature. +## +record(ai, "KM36:TST:LS:SETP4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getSETP(4) serial1 0") + field(SCAN, "1 second") + field(PREC, "3") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Read the setpoint limit +## + +## +## Read the ramp parameter. This also populates the ramp status KM36:TST:LS:RAMPST4, +## +record(ai, "KM36:TST:LS:RAMP4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getRAMP(4,KM36:TST:LS:RAMPST4) serial1 0") + field(SCAN, "5 second") + field(PREC, "3") + field(EGU, "K/min") +} + +## +## Read the ramp status parameter. +## +## 0=off +## 1=on +## +record(bi, "KM36:TST:LS:RAMPST4") { + field(DTYP, "Soft Channel") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Read the range parameter (the heater output power range). +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:RANGE4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getRANGE(4) serial1 0") +} + +## +## Read the mode to use for outmode +## This is output specific and is defined in another file. +## +record(mbbi, "KM36:TST:LS:OMMODE4") { +} + +## +## Read the manual output parameter. +## +record(ai, "KM36:TST:LS:MOUT4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getMOUT(4) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID P parameter. Pass the I and D records into the protocol to read those as well. +## +record(ai, "KM36:TST:LS:P4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getPID(4,KM36:TST:LS:I4,KM36:TST:LS:D4) serial1 0") + field(SCAN, "5 second") +} + +## +## Read the PID I parameter. +## +record(ai, "KM36:TST:LS:I4") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the PID D parameter. +## +record(ai, "KM36:TST:LS:D4") { + field(DTYP, "Soft Channel") + field(SCAN, "Passive") +} + +## +## Read the mode to use for outmode. +## This also populates the OMI and OMP records. +## The mbbi strings and values are defined in the output specific templates. +## +record(mbbi, "KM36:TST:LS:OMM4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(SCAN, "5 second") + field(INP, "@ls336.proto getOM(4,KM36:TST:LS:OMI4,KM36:TST:LS:OMP4) serial1 0") +} + +## +## Read the input to use for outmode +## +record(mbbi, "KM36:TST:LS:OMI4") { + field(DTYP, "Soft Channel") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") +} + +## +## Read the power up mode to use for outmode +## +record(mbbi, "KM36:TST:LS:OMP4") { + field(DTYP, "Soft Channel") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") +} + +################################################################ +# Write records +################################################################ + +## +## Set the setpoint temperature. +## +record(ao, "KM36:TST:LS:SETP_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Setpoint temperature") + field(OUT, "@ls336.proto setSETP(4) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:SETP_S4_BUSYSET.PROC") + field(EGU, "K") + info(archive, "Monitor, 00:00:01, VAL") +} + +############################################################################### + +## +## A few records to support put_callback on the setpoint. We use the busy record. +## A temperature window is used. The temperature must be within +## the window, before the callback is done. +## + +record(dfanout, "KM36:TST:LS:SETP_S4_BUSYSET") +{ + field(VAL, "0") + field(OUTA, "KM36:TST:LS:IN_WINDOW4.VAL PP") + field(FLNK, "KM36:TST:LS:SETP_S4_BUSYSET2") +} +record(dfanout, "KM36:TST:LS:SETP_S4_BUSYSET2") +{ + field(VAL, "1") + field(OUTA, "KM36:TST:LS:SETP4.PROC PP") + field(OUTB, "KM36:TST:LS:SETP_S4_BUSY PP") + field(FLNK, "KM36:TST:LS:CALC_IN_WINDOW4") +} +record(busy, "KM36:TST:LS:SETP_S4_BUSY") +{ +} +record(calcout, "KM36:TST:LS:CALC_IN_WINDOW4") { + field(PINI, "YES") + field(INPA, "1") + field(INPB, "KM36:TST:LS:DUMMY4.VAL") + field(INPC, "KM36:TST:LS:SETP_S4.VAL") + field(CALC, "((B>=(C-A))&&(B<=(C+A)))?1:0") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:IN_WINDOW4.VAL PP") + field(DOPT, "Use CALC") + field(SCAN, "1 second") + field(PREC, "1") + info(autosaveFields, "A") + info(archive, "Monitor, 00:00:01, A B C VAL") +} +record(bo, "KM36:TST:LS:IN_WINDOW4") { + field(DESC, "Temperature In Window") + field(VAL, "0") + field(PINI, "YES") + field(OMSL, "supervisory") + field(ZNAM, "Not In Window") + field(ONAM, "In Window") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Set busy record 'done' when TIME_WINDOW4=1 +## +record(calcout, "KM36:TST:LS:CALC_BUSY_DONE4") { + field(INPA, "KM36:TST:LS:IN_WINDOW4.VAL CP") + field(CALC, "(A=1)?0:1") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:SETP_S4_BUSY.VAL PP") +} + +############################################################################### + +## +## Dummy record to use for input link name default +## +record(ai, "KM36:TST:LS:DUMMY4") { +} + +## +## Monitor KM36:TST:LS:OMI4 to determin which input sensor to use +## to deal with the callback. The below set of records automatically +## switch the input when the 'control input' is changed. They make +## use of the input sensor PV names passed into this template. +## +record(calcout, "KM36:TST:LS:SET_4_INPUTA") { + field(CALC, "A=1") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTA_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTA_LINK") { + field(VAL, "KM36:TST:LS:KRDG0.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTB") { + field(CALC, "A=2") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTB_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTB_LINK") { + field(VAL, "KM36:TST:LS:KRDG1.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTC") { + field(CALC, "A=3") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTC_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTC_LINK") { + field(VAL, "KM36:TST:LS:KRDG2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTD") { + field(CALC, "A=4") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTD_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTD_LINK") { + field(VAL, "KM36:TST:LS:KRDG3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTD2") { + field(CALC, "A=5") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTD2_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTD2_LINK") { + field(VAL, "KM36:TST:LS:KRDGD2.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTD3") { + field(CALC, "A=6") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTD3_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTD3_LINK") { + field(VAL, "KM36:TST:LS:KRDGD3.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTD4") { + field(CALC, "A=7") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTD4_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTD4_LINK") { + field(VAL, "KM36:TST:LS:KRDGD4.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + +record(calcout, "KM36:TST:LS:SET_4_INPUTD5") { + field(CALC, "A=8") + field(INPA, "KM36:TST:LS:OMI4.VAL CP") + field(DOPT, "Use OCAL") + field(OVAL, "1") + field(OOPT, "When Non-zero") + field(OUT, "KM36:TST:LS:SET_4_INPUTD5_LINK.PROC") +} +record(stringout, "KM36:TST:LS:SET_4_INPUTD5_LINK") { + field(VAL, "KM36:TST:LS:KRDGD5.VAL CP") + field(OUT, "KM36:TST:LS:CALC_IN_WINDOW4.INPB CA") +} + + + +## +## Set the range parameter. +## The strings are output specific and is defined in another file. +## +record(mbbo, "KM36:TST:LS:RANGE_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRANGE(4) serial1 0") + field(FLNK, "KM36:TST:LS:RANGE4.PROC CA") +} + +## +## Set the ramp rate parameter. +## +## This is the desired temperate increase/decrease rate +## per second when heating/cooling. +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp status, as well as the +## desired ramp. This is done automatically by reading the +## PV which holds the current ramp status. +## +record(ao, "KM36:TST:LS:RAMP_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMP(KM36:TST:LS:RAMPST4,4) serial1 0") + field(PREC, "3") + field(FLNK, "KM36:TST:LS:RAMP4.PROC CA") + field(EGU, "K/min") +} + +## +## Set the ramp status parameter. +## +## 0=off +## 1=on +## +## The ramp and ramp status parameters are actually one command +## for the lakeshore. Therefore one must pass into this +## record the existing/desired ramp, as well as the +## desired ramp status. This is done automatically by reading the +## PV which holds the current ramp value. +## +record(bo, "KM36:TST:LS:RAMPST_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setRAMPSTATUS(KM36:TST:LS:RAMP4,4) serial1 0") + field(FLNK, "KM36:TST:LS:RAMP4.PROC CA") + field(ZNAM, "Off") + field(ONAM, "On") +} + +## +## Set the manual output value. +## +record(ao, "KM36:TST:LS:MOUT_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setMOUT(4) serial1 0") + field(FLNK, "KM36:TST:LS:MOUT4.PROC CA") +} + +## +## Set the PID P parameter. +## +record(ao, "KM36:TST:LS:P_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setP(4,KM36:TST:LS:I4,KM36:TST:LS:D4) serial1 0") + field(FLNK, "KM36:TST:LS:P4.PROC CA") +} + +## +## Set the PID I parameter. +## +record(ao, "KM36:TST:LS:I_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setI(KM36:TST:LS:P4,4,KM36:TST:LS:D4) serial1 0") + field(FLNK, "KM36:TST:LS:P4.PROC CA") +} + +## +## Set the PID D parameter. +## +record(ao, "KM36:TST:LS:D_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(OUT, "@ls336.proto setD(KM36:TST:LS:P4,KM36:TST:LS:I4,4) serial1 0") + field(FLNK, "KM36:TST:LS:P4.PROC CA") +} + +## +## Set the mode to use for outmode +## The strings are output specific. This is defined in another file. +## +record(mbbo, "KM36:TST:LS:OMM_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRVL, "0") + field(ONVL, "1") + field(TWVL, "2") + field(THVL, "3") + field(FRVL, "4") + field(FVVL, "5") + field(OUT, "@ls336.proto setOM(4,KM36:TST:LS:OMI4,KM36:TST:LS:OMP4) serial1 0") + field(FLNK, "KM36:TST:LS:OMM4.PROC CA") +} + +## +## Set the input to use for outmode +## +record(mbbo, "KM36:TST:LS:OMI_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(OUT, "@ls336.proto setOMI(4,KM36:TST:LS:OMM4,KM36:TST:LS:OMP4) serial1 0") + field(FLNK, "KM36:TST:LS:OMM4.PROC CA") +} + +## +## Set the power up mode to use for outmode +## +record(mbbo, "KM36:TST:LS:OMP_S4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "On") + field(ONVL, "1") + field(OUT, "@ls336.proto setOMP(4,KM36:TST:LS:OMM4,KM36:TST:LS:OMI4) serial1 0") + field(FLNK, "KM36:TST:LS:OMM4.PROC CA") +} + +## +## Set the type of tuning mode +## +record(mbbo, "KM36:TST:LS:TUNEMODE_S4") { + field(SDIS, "KM36:TST:LS:DISABLE") + field(ZRST, "P Only") + field(ZRVL, "0") + field(ONST, "P and I") + field(ONVL, "1") + field(TWST, "P, I and D") + field(TWVL, "2") +} + + +## +## Start the tuning process +## +record(ao, "KM36:TST:LS:TUNESTART4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE") + field(DESC, "Start the auto tuning") + field(OUT, "@ls336.proto setATUNE(4,KM36:TST:LS:TUNEMODE_S4) serial1 0") +} + + +## +## Read all ZONE settings +## +record(seq, "KM36:TST:LS:Z:READ4") { + field(DESC, "Read Output 4 ZONE") + field(DOL1, "1") + field(DLY1, "0.1") + field(LNK1, "KM36:TST:LS:Z1:ALL4.PROC") + field(DOL2, "1") + field(DLY2, "0.1") + field(LNK2, "KM36:TST:LS:Z2:ALL4.PROC") + field(DOL3, "1") + field(DLY3, "0.1") + field(LNK3, "KM36:TST:LS:Z3:ALL4.PROC") + field(DOL4, "1") + field(DLY4, "0.1") + field(LNK4, "KM36:TST:LS:Z4:ALL4.PROC") + field(DOL5, "1") + field(DLY5, "0.1") + field(LNK5, "KM36:TST:LS:Z5:ALL4.PROC") + field(DOL6, "1") + field(DLY6, "0.1") + field(LNK6, "KM36:TST:LS:Z6:ALL4.PROC") + field(DOL7, "1") + field(DLY7, "0.1") + field(LNK7, "KM36:TST:LS:Z7:ALL4.PROC") + field(DOL8, "1") + field(DLY8, "0.1") + field(LNK8, "KM36:TST:LS:Z8:ALL4.PROC") + field(DOL9, "1") + field(DLY9, "0.1") + field(LNK9, "KM36:TST:LS:Z9:ALL4.PROC") + field(DOLA, "1") + field(DLYA, "0.1") + field(LNKA, "KM36:TST:LS:Z10:ALL4.PROC") + field(PINI, "YES") +} + +############################################### +# This is included in lakeshore336.template +# This is for the analog outputs (3 and 4) + +## +## Read the analog output value. +## +record(ai, "KM36:TST:LS:AOUT4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getAOUT(4) serial1 0") + field(SCAN, "5 second") + field(PREC, "1") + field(EGU, "%") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Define the string/values for this record. +## +record(mbbi, "KM36:TST:LS:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") +} + +## +## Define the strings and values for this record. +## +record(mbbi, "KM36:TST:LS:OMM4") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") + field(FRST, "Monitor Out") + field(FVST, "Warmup Supply") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") +} + +## +## Define the strings and values for this record. +## +record(mbbo, "KM36:TST:LS:OMM_S4") { + field(ZRST, "Off") + field(ONST, "Closed Loop PID") + field(TWST, "Zone") + field(THST, "Open Loop") + field(FRST, "Monitor Out") + field(FVST, "Warmup Supply") +} + +############################################### +# Add in ZONE support +############################################### + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z1:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,1) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z1:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z1:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z1:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:P4.PROC") +} +record(ai, "KM36:TST:LS:Z1:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z1:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:I4.PROC") +} +record(ai, "KM36:TST:LS:Z1:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z1:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:D4.PROC") +} +record(ai, "KM36:TST:LS:Z1:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z1:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z1:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z1:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:RANGE4") { + field(INP, "KM36:TST:LS:Z1:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z1:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z1:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z1:INPUT4") { + field(INP, "KM36:TST:LS:Z1:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z1:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z1:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z1:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z1:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z1:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z1:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z1:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z1:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z1:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:P4.VAL") + field(OUTA, "KM36:TST:LS:Z1:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:I4.VAL") + field(OUTA, "KM36:TST:LS:Z1:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:D4.VAL") + field(OUTA, "KM36:TST:LS:Z1:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z1:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z1:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z1:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z1:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z1:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z1:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z1:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z1:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z1:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z1:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z1:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z1:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z1:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z1:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z1:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z1:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z1:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z1:SET4") { + field(INPA, "KM36:TST:LS:Z1:UB_S4") + field(INPB, "KM36:TST:LS:Z1:P_S4") + field(INPC, "KM36:TST:LS:Z1:I_S4") + field(INPD, "KM36:TST:LS:Z1:D_S4") + field(INPE, "KM36:TST:LS:Z1:MOUT_S4") + field(INPF, "KM36:TST:LS:Z1:RANGE_S4") + field(INPG, "KM36:TST:LS:Z1:INPUT_S4") + field(INPH, "KM36:TST:LS:Z1:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,1) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z1:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z1:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z1:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P4.PROC") +} +record(ai, "KM36:TST:LS:Z2:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I4.PROC") +} +record(ai, "KM36:TST:LS:Z2:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D4.PROC") +} +record(ai, "KM36:TST:LS:Z2:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE4") { + field(INP, "KM36:TST:LS:Z2:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT4") { + field(INP, "KM36:TST:LS:Z2:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P4.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I4.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D4.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET4") { + field(INPA, "KM36:TST:LS:Z2:UB_S4") + field(INPB, "KM36:TST:LS:Z2:P_S4") + field(INPC, "KM36:TST:LS:Z2:I_S4") + field(INPD, "KM36:TST:LS:Z2:D_S4") + field(INPE, "KM36:TST:LS:Z2:MOUT_S4") + field(INPF, "KM36:TST:LS:Z2:RANGE_S4") + field(INPG, "KM36:TST:LS:Z2:INPUT_S4") + field(INPH, "KM36:TST:LS:Z2:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z2:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z2:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z2:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,2) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z2:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z2:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z2:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:P4.PROC") +} +record(ai, "KM36:TST:LS:Z2:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z2:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:I4.PROC") +} +record(ai, "KM36:TST:LS:Z2:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z2:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:D4.PROC") +} +record(ai, "KM36:TST:LS:Z2:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z2:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z2:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z2:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:RANGE4") { + field(INP, "KM36:TST:LS:Z2:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z2:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z2:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z2:INPUT4") { + field(INP, "KM36:TST:LS:Z2:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z2:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z2:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z2:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z2:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z2:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z2:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z2:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z2:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z2:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:P4.VAL") + field(OUTA, "KM36:TST:LS:Z2:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:I4.VAL") + field(OUTA, "KM36:TST:LS:Z2:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:D4.VAL") + field(OUTA, "KM36:TST:LS:Z2:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z2:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z2:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z2:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z2:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z2:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z2:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z2:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z2:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z2:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z2:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z2:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z2:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z2:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z2:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z2:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z2:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z2:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z2:SET4") { + field(INPA, "KM36:TST:LS:Z2:UB_S4") + field(INPB, "KM36:TST:LS:Z2:P_S4") + field(INPC, "KM36:TST:LS:Z2:I_S4") + field(INPD, "KM36:TST:LS:Z2:D_S4") + field(INPE, "KM36:TST:LS:Z2:MOUT_S4") + field(INPF, "KM36:TST:LS:Z2:RANGE_S4") + field(INPG, "KM36:TST:LS:Z2:INPUT_S4") + field(INPH, "KM36:TST:LS:Z2:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,2) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z2:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z2:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z2:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z3:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,3) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z3:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z3:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z3:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:P4.PROC") +} +record(ai, "KM36:TST:LS:Z3:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z3:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:I4.PROC") +} +record(ai, "KM36:TST:LS:Z3:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z3:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:D4.PROC") +} +record(ai, "KM36:TST:LS:Z3:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z3:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z3:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z3:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:RANGE4") { + field(INP, "KM36:TST:LS:Z3:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z3:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z3:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z3:INPUT4") { + field(INP, "KM36:TST:LS:Z3:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z3:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z3:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z3:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z3:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z3:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z3:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z3:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z3:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z3:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:P4.VAL") + field(OUTA, "KM36:TST:LS:Z3:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:I4.VAL") + field(OUTA, "KM36:TST:LS:Z3:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:D4.VAL") + field(OUTA, "KM36:TST:LS:Z3:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z3:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z3:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z3:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z3:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z3:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z3:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z3:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z3:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z3:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z3:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z3:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z3:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z3:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z3:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z3:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z3:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z3:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z3:SET4") { + field(INPA, "KM36:TST:LS:Z3:UB_S4") + field(INPB, "KM36:TST:LS:Z3:P_S4") + field(INPC, "KM36:TST:LS:Z3:I_S4") + field(INPD, "KM36:TST:LS:Z3:D_S4") + field(INPE, "KM36:TST:LS:Z3:MOUT_S4") + field(INPF, "KM36:TST:LS:Z3:RANGE_S4") + field(INPG, "KM36:TST:LS:Z3:INPUT_S4") + field(INPH, "KM36:TST:LS:Z3:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,3) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z3:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z3:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z3:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z4:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,4) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z4:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z4:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z4:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:P4.PROC") +} +record(ai, "KM36:TST:LS:Z4:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z4:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:I4.PROC") +} +record(ai, "KM36:TST:LS:Z4:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z4:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:D4.PROC") +} +record(ai, "KM36:TST:LS:Z4:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z4:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z4:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z4:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:RANGE4") { + field(INP, "KM36:TST:LS:Z4:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z4:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z4:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z4:INPUT4") { + field(INP, "KM36:TST:LS:Z4:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z4:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z4:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z4:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z4:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z4:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z4:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z4:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z4:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z4:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:P4.VAL") + field(OUTA, "KM36:TST:LS:Z4:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:I4.VAL") + field(OUTA, "KM36:TST:LS:Z4:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:D4.VAL") + field(OUTA, "KM36:TST:LS:Z4:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z4:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z4:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z4:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z4:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z4:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z4:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z4:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z4:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z4:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z4:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z4:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z4:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z4:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z4:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z4:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z4:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z4:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z4:SET4") { + field(INPA, "KM36:TST:LS:Z4:UB_S4") + field(INPB, "KM36:TST:LS:Z4:P_S4") + field(INPC, "KM36:TST:LS:Z4:I_S4") + field(INPD, "KM36:TST:LS:Z4:D_S4") + field(INPE, "KM36:TST:LS:Z4:MOUT_S4") + field(INPF, "KM36:TST:LS:Z4:RANGE_S4") + field(INPG, "KM36:TST:LS:Z4:INPUT_S4") + field(INPH, "KM36:TST:LS:Z4:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,4) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z4:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z4:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z4:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z5:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,5) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z5:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z5:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z5:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:P4.PROC") +} +record(ai, "KM36:TST:LS:Z5:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z5:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:I4.PROC") +} +record(ai, "KM36:TST:LS:Z5:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z5:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:D4.PROC") +} +record(ai, "KM36:TST:LS:Z5:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z5:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z5:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z5:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:RANGE4") { + field(INP, "KM36:TST:LS:Z5:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z5:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z5:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z5:INPUT4") { + field(INP, "KM36:TST:LS:Z5:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z5:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z5:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z5:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z5:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z5:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z5:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z5:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z5:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z5:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:P4.VAL") + field(OUTA, "KM36:TST:LS:Z5:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:I4.VAL") + field(OUTA, "KM36:TST:LS:Z5:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:D4.VAL") + field(OUTA, "KM36:TST:LS:Z5:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z5:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z5:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z5:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z5:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z5:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z5:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z5:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z5:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z5:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z5:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z5:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z5:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z5:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z5:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z5:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z5:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z5:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z5:SET4") { + field(INPA, "KM36:TST:LS:Z5:UB_S4") + field(INPB, "KM36:TST:LS:Z5:P_S4") + field(INPC, "KM36:TST:LS:Z5:I_S4") + field(INPD, "KM36:TST:LS:Z5:D_S4") + field(INPE, "KM36:TST:LS:Z5:MOUT_S4") + field(INPF, "KM36:TST:LS:Z5:RANGE_S4") + field(INPG, "KM36:TST:LS:Z5:INPUT_S4") + field(INPH, "KM36:TST:LS:Z5:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,5) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z5:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z5:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z5:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z6:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,6) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z6:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z6:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z6:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:P4.PROC") +} +record(ai, "KM36:TST:LS:Z6:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z6:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:I4.PROC") +} +record(ai, "KM36:TST:LS:Z6:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z6:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:D4.PROC") +} +record(ai, "KM36:TST:LS:Z6:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z6:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z6:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z6:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:RANGE4") { + field(INP, "KM36:TST:LS:Z6:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z6:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z6:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z6:INPUT4") { + field(INP, "KM36:TST:LS:Z6:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z6:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z6:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z6:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z6:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z6:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z6:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z6:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z6:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z6:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:P4.VAL") + field(OUTA, "KM36:TST:LS:Z6:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:I4.VAL") + field(OUTA, "KM36:TST:LS:Z6:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:D4.VAL") + field(OUTA, "KM36:TST:LS:Z6:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z6:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z6:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z6:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z6:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z6:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z6:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z6:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z6:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z6:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z6:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z6:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z6:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z6:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z6:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z6:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z6:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z6:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z6:SET4") { + field(INPA, "KM36:TST:LS:Z6:UB_S4") + field(INPB, "KM36:TST:LS:Z6:P_S4") + field(INPC, "KM36:TST:LS:Z6:I_S4") + field(INPD, "KM36:TST:LS:Z6:D_S4") + field(INPE, "KM36:TST:LS:Z6:MOUT_S4") + field(INPF, "KM36:TST:LS:Z6:RANGE_S4") + field(INPG, "KM36:TST:LS:Z6:INPUT_S4") + field(INPH, "KM36:TST:LS:Z6:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,6) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z6:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z6:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z6:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z7:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,7) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z7:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z7:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z7:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:P4.PROC") +} +record(ai, "KM36:TST:LS:Z7:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z7:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:I4.PROC") +} +record(ai, "KM36:TST:LS:Z7:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z7:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:D4.PROC") +} +record(ai, "KM36:TST:LS:Z7:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z7:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z7:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z7:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:RANGE4") { + field(INP, "KM36:TST:LS:Z7:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z7:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z7:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z7:INPUT4") { + field(INP, "KM36:TST:LS:Z7:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z7:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z7:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z7:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z7:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z7:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z7:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z7:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z7:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z7:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:P4.VAL") + field(OUTA, "KM36:TST:LS:Z7:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:I4.VAL") + field(OUTA, "KM36:TST:LS:Z7:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:D4.VAL") + field(OUTA, "KM36:TST:LS:Z7:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z7:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z7:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z7:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z7:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z7:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z7:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z7:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z7:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z7:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z7:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z7:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z7:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z7:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z7:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z7:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z7:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z7:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z7:SET4") { + field(INPA, "KM36:TST:LS:Z7:UB_S4") + field(INPB, "KM36:TST:LS:Z7:P_S4") + field(INPC, "KM36:TST:LS:Z7:I_S4") + field(INPD, "KM36:TST:LS:Z7:D_S4") + field(INPE, "KM36:TST:LS:Z7:MOUT_S4") + field(INPF, "KM36:TST:LS:Z7:RANGE_S4") + field(INPG, "KM36:TST:LS:Z7:INPUT_S4") + field(INPH, "KM36:TST:LS:Z7:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,7) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z7:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z7:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z7:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z8:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,8) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z8:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z8:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z8:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:P4.PROC") +} +record(ai, "KM36:TST:LS:Z8:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z8:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:I4.PROC") +} +record(ai, "KM36:TST:LS:Z8:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z8:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:D4.PROC") +} +record(ai, "KM36:TST:LS:Z8:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z8:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z8:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z8:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:RANGE4") { + field(INP, "KM36:TST:LS:Z8:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z8:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z8:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z8:INPUT4") { + field(INP, "KM36:TST:LS:Z8:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z8:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z8:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z8:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z8:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z8:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z8:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z8:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z8:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z8:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:P4.VAL") + field(OUTA, "KM36:TST:LS:Z8:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:I4.VAL") + field(OUTA, "KM36:TST:LS:Z8:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:D4.VAL") + field(OUTA, "KM36:TST:LS:Z8:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z8:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z8:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z8:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z8:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z8:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z8:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z8:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z8:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z8:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z8:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z8:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z8:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z8:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z8:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z8:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z8:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z8:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z8:SET4") { + field(INPA, "KM36:TST:LS:Z8:UB_S4") + field(INPB, "KM36:TST:LS:Z8:P_S4") + field(INPC, "KM36:TST:LS:Z8:I_S4") + field(INPD, "KM36:TST:LS:Z8:D_S4") + field(INPE, "KM36:TST:LS:Z8:MOUT_S4") + field(INPF, "KM36:TST:LS:Z8:RANGE_S4") + field(INPG, "KM36:TST:LS:Z8:INPUT_S4") + field(INPH, "KM36:TST:LS:Z8:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,8) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z8:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z8:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z8:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z9:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,9) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z9:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z9:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z9:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:P4.PROC") +} +record(ai, "KM36:TST:LS:Z9:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z9:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:I4.PROC") +} +record(ai, "KM36:TST:LS:Z9:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z9:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:D4.PROC") +} +record(ai, "KM36:TST:LS:Z9:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z9:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z9:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z9:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:RANGE4") { + field(INP, "KM36:TST:LS:Z9:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z9:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z9:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z9:INPUT4") { + field(INP, "KM36:TST:LS:Z9:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z9:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z9:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z9:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z9:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z9:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z9:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z9:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z9:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z9:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:P4.VAL") + field(OUTA, "KM36:TST:LS:Z9:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:I4.VAL") + field(OUTA, "KM36:TST:LS:Z9:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:D4.VAL") + field(OUTA, "KM36:TST:LS:Z9:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z9:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z9:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z9:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z9:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z9:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z9:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z9:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z9:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z9:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z9:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z9:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z9:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z9:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z9:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z9:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z9:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z9:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z9:SET4") { + field(INPA, "KM36:TST:LS:Z9:UB_S4") + field(INPB, "KM36:TST:LS:Z9:P_S4") + field(INPC, "KM36:TST:LS:Z9:I_S4") + field(INPD, "KM36:TST:LS:Z9:D_S4") + field(INPE, "KM36:TST:LS:Z9:MOUT_S4") + field(INPF, "KM36:TST:LS:Z9:RANGE_S4") + field(INPG, "KM36:TST:LS:Z9:INPUT_S4") + field(INPH, "KM36:TST:LS:Z9:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,9) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z9:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z9:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z9:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z10:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,10) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z10:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z10:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z10:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P4.PROC") +} +record(ai, "KM36:TST:LS:Z10:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z10:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I4.PROC") +} +record(ai, "KM36:TST:LS:Z10:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z10:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D4.PROC") +} +record(ai, "KM36:TST:LS:Z10:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z10:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z10:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z10:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:RANGE4") { + field(INP, "KM36:TST:LS:Z10:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z10:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z10:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:INPUT4") { + field(INP, "KM36:TST:LS:Z10:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z10:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z10:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z10:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z10:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z10:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z10:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:P4.VAL") + field(OUTA, "KM36:TST:LS:Z10:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:I4.VAL") + field(OUTA, "KM36:TST:LS:Z10:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:D4.VAL") + field(OUTA, "KM36:TST:LS:Z10:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z10:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z10:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z10:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z10:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z10:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z10:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z10:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z10:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z10:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z10:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z10:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z10:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z10:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z10:SET4") { + field(INPA, "KM36:TST:LS:Z10:UB_S4") + field(INPB, "KM36:TST:LS:Z10:P_S4") + field(INPC, "KM36:TST:LS:Z10:I_S4") + field(INPD, "KM36:TST:LS:Z10:D_S4") + field(INPE, "KM36:TST:LS:Z10:MOUT_S4") + field(INPF, "KM36:TST:LS:Z10:RANGE_S4") + field(INPG, "KM36:TST:LS:Z10:INPUT_S4") + field(INPH, "KM36:TST:LS:Z10:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,10) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z10:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z10:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z10:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z10:ALL3") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(3,10) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB3:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z10:UB3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB3.PROC") +} +record(ai, "KM36:TST:LS:Z10:UB3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:UB3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P3:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z10:P3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P3.PROC") +} +record(ai, "KM36:TST:LS:Z10:P3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:P3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I3:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z10:I3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I3.PROC") +} +record(ai, "KM36:TST:LS:Z10:I3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:I3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D3:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z10:D3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D3.PROC") +} +record(ai, "KM36:TST:LS:Z10:D3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:D3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT3:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z10:MOUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT3.PROC") +} +record(ai, "KM36:TST:LS:Z10:MOUT3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:MOUT3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE3:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z10:RANGE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE3.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:RANGE3") { + field(INP, "KM36:TST:LS:Z10:RANGE3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z10:INPUT3:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z10:INPUT3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INPUT3.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:INPUT3") { + field(INP, "KM36:TST:LS:Z10:INPUT3:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z10:RATE3:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z10:RATE3:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL3.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RATE3.PROC") +} +record(ai, "KM36:TST:LS:Z10:RATE3") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:RATE3:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INITCALC3.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z10:INITCALC3") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z10:INITUB3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITUB3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:UB3.VAL") + field(OUTA, "KM36:TST:LS:Z10:UB_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITP3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITP3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:P3.VAL") + field(OUTA, "KM36:TST:LS:Z10:P_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITI3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITI3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:I3.VAL") + field(OUTA, "KM36:TST:LS:Z10:I_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITD3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITD3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:D3.VAL") + field(OUTA, "KM36:TST:LS:Z10:D_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITMOUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITMOUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:MOUT3.VAL") + field(OUTA, "KM36:TST:LS:Z10:MOUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRANGE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRANGE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RANGE3.VAL") + field(OUTA, "KM36:TST:LS:Z10:RANGE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITINPUT3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITINPUT3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:INPUT3.VAL") + field(OUTA, "KM36:TST:LS:Z10:INPUT_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRATE3.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRATE3") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RATE3.VAL") + field(OUTA, "KM36:TST:LS:Z10:RATE_S3.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITCOUNT3.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITCOUNT3") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z10:INITCALC3.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z10:UB_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z10:P_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z10:I_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z10:D_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z10:MOUT_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z10:RANGE_S3") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z10:INPUT_S3") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z10:RATE_S3") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z10:SET3") { + field(INPA, "KM36:TST:LS:Z10:UB_S3") + field(INPB, "KM36:TST:LS:Z10:P_S3") + field(INPC, "KM36:TST:LS:Z10:I_S3") + field(INPD, "KM36:TST:LS:Z10:D_S3") + field(INPE, "KM36:TST:LS:Z10:MOUT_S3") + field(INPF, "KM36:TST:LS:Z10:RANGE_S3") + field(INPG, "KM36:TST:LS:Z10:INPUT_S3") + field(INPH, "KM36:TST:LS:Z10:RATE_S3") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(3,10) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z10:ALL3.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z10:RANGE3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z10:RANGE_S3") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + + +# This just includes the zone file and overrides the RANGE options +# for the analog control channels. + +####################################### +# +# Template to support reading and setting +# controller ZONE parameters. It reads the ZONE +# parameters into an array, then uses subArrays to +# extract each parameter. +# +# This template is used by the output template +# and it needs the following macros: +# +# ZONE: zone number +# OUT: output number +# +####################################### + +## +## Read the ZONE setting into an array (8 values) +## +record(waveform, "KM36:TST:LS:Z10:ALL4") { + field(DTYP, "stream") + field(SDIS, "KM36:TST:LS:DISABLE_POLL") + field(INP, "@ls336.proto getZONE(4,10) serial1 0") + field(SCAN, "Passive") + field(NELM, "8") + field(FTVL, "DOUBLE") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB4:ARRAY.PROC") +} + +## +## Read the ZONE upper boundary setting. +## +record(subArray, "KM36:TST:LS:Z10:UB4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "0") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:UB4.PROC") +} +record(ai, "KM36:TST:LS:Z10:UB4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:UB4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P4:ARRAY.PROC") +} + +## +## Read the ZONE P setting. +## +record(subArray, "KM36:TST:LS:Z10:P4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "1") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:P4.PROC") +} +record(ai, "KM36:TST:LS:Z10:P4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:P4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I4:ARRAY.PROC") +} + +## +## Read the ZONE I setting. +## +record(subArray, "KM36:TST:LS:Z10:I4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "2") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:I4.PROC") +} +record(ai, "KM36:TST:LS:Z10:I4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:I4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D4:ARRAY.PROC") +} + +## +## Read the ZONE D setting. +## +record(subArray, "KM36:TST:LS:Z10:D4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "3") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:D4.PROC") +} +record(ai, "KM36:TST:LS:Z10:D4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:D4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT4:ARRAY.PROC") +} + +## +## Read the ZONE MOUT setting. +## +record(subArray, "KM36:TST:LS:Z10:MOUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "4") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:MOUT4.PROC") +} +record(ai, "KM36:TST:LS:Z10:MOUT4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:MOUT4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE4:ARRAY.PROC") +} + +## +## Read the ZONE RANGE setting. +## +record(subArray, "KM36:TST:LS:Z10:RANGE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "5") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RANGE4.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:RANGE4") { + field(INP, "KM36:TST:LS:Z10:RANGE4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(FLNK, "KM36:TST:LS:Z10:INPUT4:ARRAY.PROC") +} + +## +## Read the ZONE INPUT setting. +## +record(subArray, "KM36:TST:LS:Z10:INPUT4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "6") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INPUT4.PROC") +} +record(mbbi, "KM36:TST:LS:Z10:INPUT4") { + field(INP, "KM36:TST:LS:Z10:INPUT4:ARRAY.VAL") + field(SCAN, "Passive") + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(FLNK, "KM36:TST:LS:Z10:RATE4:ARRAY.PROC") +} + +## +## Read the ZONE RATE setting. +## +record(subArray, "KM36:TST:LS:Z10:RATE4:ARRAY") { + field(SCAN, "Passive") + field(FTVL, "DOUBLE") + field(INP, "KM36:TST:LS:Z10:ALL4.VAL MS") + field(MALM, "8") + field(NELM, "1") + field(INDX, "7") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:RATE4.PROC") +} +record(ai, "KM36:TST:LS:Z10:RATE4") { + field(SCAN, "Passive") + field(INP, "KM36:TST:LS:Z10:RATE4:ARRAY.VAL MS") + field(PREC, "1") + field(FLNK, "KM36:TST:LS:Z10:INITCALC4.PROC") +} + +############################################################## +## +## Populate the write records below with the current values. +## Only do this once at startup. +## +############################################################### + +record(calcout, "KM36:TST:LS:Z10:INITCALC4") { + field(INPA, "0") + field(CALC, "A") + field(VAL, "0") + field(DOPT, "Use OCAL") + field(OOPT, "When Zero") + field(OCAL, "1") + field(OUT, "KM36:TST:LS:Z10:INITUB4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITUB4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:UB4.VAL") + field(OUTA, "KM36:TST:LS:Z10:UB_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITP4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITP4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:P4.VAL") + field(OUTA, "KM36:TST:LS:Z10:P_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITI4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITI4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:I4.VAL") + field(OUTA, "KM36:TST:LS:Z10:I_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITD4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITD4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:D4.VAL") + field(OUTA, "KM36:TST:LS:Z10:D_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITMOUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITMOUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:MOUT4.VAL") + field(OUTA, "KM36:TST:LS:Z10:MOUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRANGE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRANGE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RANGE4.VAL") + field(OUTA, "KM36:TST:LS:Z10:RANGE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITINPUT4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITINPUT4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:INPUT4.VAL") + field(OUTA, "KM36:TST:LS:Z10:INPUT_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITRATE4.PROC") +} +record(dfanout, "KM36:TST:LS:Z10:INITRATE4") { + field(OMSL, "closed_loop") + field(DOL, "KM36:TST:LS:Z10:RATE4.VAL") + field(OUTA, "KM36:TST:LS:Z10:RATE_S4.VAL PP") + field(FLNK, "KM36:TST:LS:Z10:INITCOUNT4.PROC") +} + +record(dfanout, "KM36:TST:LS:Z10:INITCOUNT4") { + field(DOL, "1") + field(OUTA, "KM36:TST:LS:Z10:INITCALC4.A") +} + + + +############################################# +# Write records. There is a calcout record to +# do the actual write. +############################################# + +## +## Set the ZONE upper boundary setting. +## +record(ao, "KM36:TST:LS:Z10:UB_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE P setting. +## +record(ao, "KM36:TST:LS:Z10:P_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE I setting. +## +record(ao, "KM36:TST:LS:Z10:I_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE D setting. +## +record(ao, "KM36:TST:LS:Z10:D_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE MOUT setting. +## +record(ao, "KM36:TST:LS:Z10:MOUT_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RANGE setting. +## +record(mbbo, "KM36:TST:LS:Z10:RANGE_S4") { + field(SCAN, "Passive") + field(ZRST, "Off") + field(ZRVL, "0") + field(ONST, "Range1/Low") + field(ONVL, "1") + field(TWST, "Range2/Medium") + field(TWVL, "2") + field(THST, "Range3/High") + field(THVL, "3") + field(FRST, "Range4") + field(FRVL, "4") + field(FVST, "Range5") + field(FVVL, "5") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE INPUT setting. +## +record(mbbo, "KM36:TST:LS:Z10:INPUT_S4") { + field(ZRST, "None") + field(ZRVL, "0") + field(ONST, "Input A") + field(ONVL, "1") + field(TWST, "Input B") + field(TWVL, "2") + field(THST, "Input C") + field(THVL, "3") + field(FRST, "Input D") + field(FRVL, "4") + field(FVST, "Input D2") + field(FVVL, "5") + field(SXST, "Input D3") + field(SXVL, "6") + field(SVST, "Input D4") + field(SVVL, "7") + field(EIST, "Input D5") + field(EIVL, "8") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Set the ZONE RATE setting. +## +record(ao, "KM36:TST:LS:Z10:RATE_S4") { + field(SCAN, "Passive") + field(PREC, "1") + field(SDIS, "KM36:TST:LS:DISABLE") +} + +## +## Record to write the ZONE parameters. +## +record(calcout, "KM36:TST:LS:Z10:SET4") { + field(INPA, "KM36:TST:LS:Z10:UB_S4") + field(INPB, "KM36:TST:LS:Z10:P_S4") + field(INPC, "KM36:TST:LS:Z10:I_S4") + field(INPD, "KM36:TST:LS:Z10:D_S4") + field(INPE, "KM36:TST:LS:Z10:MOUT_S4") + field(INPF, "KM36:TST:LS:Z10:RANGE_S4") + field(INPG, "KM36:TST:LS:Z10:INPUT_S4") + field(INPH, "KM36:TST:LS:Z10:RATE_S4") + field(CALC, "0") + field(DTYP, "stream") + field(OUT, "@ls336.proto setZONE(4,10) serial1 0") + field(SDIS, "KM36:TST:LS:DISABLE") + field(FLNK, "KM36:TST:LS:Z10:ALL4.PROC") +} + + + + + + + + + + +record(mbbi, "KM36:TST:LS:Z10:RANGE4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + +record(mbbo, "KM36:TST:LS:Z10:RANGE_S4") { + field(ZRST, "Off") + field(ONST, "On") + field(TWST, "") + field(THST, "") + field(FRST, "") + field(FVST, "") +} + + + + + +################################################################ +# Records dealing with alarm handling + +## +## Disable top level alarm handling +## +record(bo, "KM36:TST:LS:DISABLE_ALARM") { + field(DESC, "Disable Alarms") + field(PINI, "YES") + field(VAL, "0") + field(OMSL, "supervisory") + field(ZNAM, "Alarm Enabled") + field(ONAM, "Alarm Disabled") + field(ZSV, "NO_ALARM") + field(OSV, "MINOR") + field(FLNK, "KM36:TST:LS:ALARM_SUMMARY_CALC") + info(autosaveFields, "VAL") +} + +#record(bo, "KM36:TST:LS:DISABLE_ALARM_CALC") { +# field(DESC, "Disable Alarms Calc") +# field(VAL, "1") +# field(OUT, "KM36:TST:LS:ALARM_SUMMARY_CALC.DISA PP") +# field(FLNK, "KM36:TST:LS:ALARM_SUMMARY_CALC2") +#} + +## +## If we disable the alarm handling, clear the alarm status +## +record(calcout, "KM36:TST:LS:DISABLE_ALARM_SETZERO") { + field(INPA, "KM36:TST:LS:DISABLE_ALARM CP") + field(CALC, "A==1?0:1") + field(DOPT, "Use CALC") + field(OOPT, "When Zero") + field(OUT, "KM36:TST:LS:ALARM_SUMMARY.VAL PP") +} + +record(calc, "KM36:TST:LS:ALARM_SUMMARY_CALC") { + field(INPA, "KM36:TST:LS:ALARM0_SUMMARY CP MS") + field(INPB, "KM36:TST:LS:ALARM1_SUMMARY CP MS") + field(INPC, "KM36:TST:LS:ALARM2_SUMMARY CP MS") + field(INPD, "KM36:TST:LS:ALARM3_SUMMARY CP MS") + field(INPE, "KM36:TST:LS:ALARMD2_SUMMARY CP MS") + field(INPF, "KM36:TST:LS:ALARMD3_SUMMARY CP MS") + field(INPG, "KM36:TST:LS:ALARMD4_SUMMARY CP MS") + field(INPH, "KM36:TST:LS:ALARMD5_SUMMARY CP MS") + field(INPI, "KM36:TST:LS:HTRST1_CACHE CP MS") + field(INPJ, "KM36:TST:LS:HTRST2_CACHE CP MS") + field(CALC, "A") + field(FLNK, "KM36:TST:LS:ALARM_SUMMARY_CALC2") + field(SDIS, "KM36:TST:LS:DISABLE_ALARM") +} +record(calcout, "KM36:TST:LS:ALARM_SUMMARY_CALC2") { + field(INPA, "KM36:TST:LS:ALARM_SUMMARY_CALC.STAT") + field(CALC, "A!=0?1:0") + field(DOPT, "Use CALC") + field(OOPT, "Every Time") + field(OUT, "KM36:TST:LS:ALARM_SUMMARY PP") +} + +## +## Top level alarm summary record. +## This summarizes the input alarm summary record +## along with the two main output heater status records +## which are on loop 1 and 2. +## +record(bi, "KM36:TST:LS:ALARM_SUMMARY") { + field(ZNAM, "No Alarm") + field(ONAM, "Alarm") + field(OSV, "MAJOR") + field(PINI, "YES") + field(VAL, "0") + info(archive, "Monitor, 00:00:01, VAL") +} + +## +## Generic Asyn record for reading parameters. +## +record(asyn,"KM36:TST:LS:ASYN") +{ + field(DTYP,"asynRecordDevice") + field(PORT,"serial1") + field(ADDR,"0") + field(OMAX,"1024") + field(IMAX,"1024") + field(OEOS,"\r\n") + field(IEOS,"\r\n") +} diff --git a/iocBoot/iocsinqEPICS/lakeshore.substitutions b/iocBoot/iocsinqEPICS/lakeshore.substitutions new file mode 100644 index 0000000..a26c39f --- /dev/null +++ b/iocBoot/iocsinqEPICS/lakeshore.substitutions @@ -0,0 +1,5 @@ +file "lakeshore336.template" +{ + pattern {P, PORT, ADDR, TEMPSCAN, SCAN} + {KM36:TST:LS,serial1,0, 1, 5} +} diff --git a/sinqEPICSApp/src/Makefile b/sinqEPICSApp/src/Makefile index 5ddf24c..9324de3 100644 --- a/sinqEPICSApp/src/Makefile +++ b/sinqEPICSApp/src/Makefile @@ -20,7 +20,7 @@ sinqEPICS_DBD += sinq.dbd sinqEPICS_DBD += pmacAsynIPPort.dbd pmacAsynMotorPort.dbd # Add all the support libraries needed by this IOC -sinqEPICS_LIBS += motor asyn std anc350 anc350AsynMotor +sinqEPICS_LIBS += motor asyn std anc350 anc350AsynMotor stream busy # sinqEPICS_registerRecordDeviceDriver.cpp derives from sinqEPICS.dbd sinqEPICS_SRCS += sinqEPICS_registerRecordDeviceDriver.cpp diff --git a/sinqEPICSApp/src/sinq.dbd b/sinqEPICSApp/src/sinq.dbd index b0ce13a..f844a03 100644 --- a/sinqEPICSApp/src/sinq.dbd +++ b/sinqEPICSApp/src/sinq.dbd @@ -16,3 +16,8 @@ include "anc350AsynMotor.dbd" include "scalerRecord.dbd" device(scaler,INST_IO,devScalerEL737,"asynScalerEL737") +#--------- For lakeshore +addpath "/usr/local/epics/support/StreamDevice-2-6/dbd" +include "stream.dbd" +addpath "/usr/local/epics/support/busy-1-4/dbd" +include "busySupport.dbd"