--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?fileVersion 4.0.0?>
+
+<cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
+ <storageModule moduleId="org.eclipse.cdt.core.settings">
+ <cconfiguration id="0.1482250461">
+ <storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="0.1482250461" moduleId="org.eclipse.cdt.core.settings" name="Default">
+ <externalSettings/>
+ <extensions>
+ <extension id="org.eclipse.cdt.core.VCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+ <extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+ <extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
+ <extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+ <extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+ <extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+ </extensions>
+ </storageModule>
+ <storageModule moduleId="cdtBuildSystem" version="4.0.0">
+ <configuration buildProperties="" description="" id="0.1482250461" name="Default" parent="org.eclipse.cdt.build.core.prefbase.cfg">
+ <folderInfo id="0.1482250461." name="/" resourcePath="">
+ <toolChain id="org.eclipse.cdt.build.core.prefbase.toolchain.954335981" name="No ToolChain" resourceTypeBasedDiscovery="false" superClass="org.eclipse.cdt.build.core.prefbase.toolchain">
+ <targetPlatform id="org.eclipse.cdt.build.core.prefbase.toolchain.954335981.1546326173" name=""/>
+ <builder id="org.eclipse.cdt.build.core.settings.default.builder.408952329" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
+ <tool id="org.eclipse.cdt.build.core.settings.holder.libs.2124377927" name="holder for library settings" superClass="org.eclipse.cdt.build.core.settings.holder.libs"/>
+ <tool id="org.eclipse.cdt.build.core.settings.holder.1460314390" name="Assembly" superClass="org.eclipse.cdt.build.core.settings.holder">
+ <inputType id="org.eclipse.cdt.build.core.settings.holder.inType.648769722" languageId="org.eclipse.cdt.core.assembly" languageName="Assembly" sourceContentType="org.eclipse.cdt.core.asmSource" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
+ </tool>
+ <tool id="org.eclipse.cdt.build.core.settings.holder.1131100334" name="GNU C++" superClass="org.eclipse.cdt.build.core.settings.holder">
+ <inputType id="org.eclipse.cdt.build.core.settings.holder.inType.381283868" languageId="org.eclipse.cdt.core.g++" languageName="GNU C++" sourceContentType="org.eclipse.cdt.core.cxxSource,org.eclipse.cdt.core.cxxHeader" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
+ </tool>
+ <tool id="org.eclipse.cdt.build.core.settings.holder.203774813" name="GNU C" superClass="org.eclipse.cdt.build.core.settings.holder">
+ <inputType id="org.eclipse.cdt.build.core.settings.holder.inType.781895277" languageId="org.eclipse.cdt.core.gcc" languageName="GNU C" sourceContentType="org.eclipse.cdt.core.cSource,org.eclipse.cdt.core.cHeader" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
+ </tool>
+ </toolChain>
+ </folderInfo>
+ </configuration>
+ </storageModule>
+ <storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+ </cconfiguration>
+ </storageModule>
+ <storageModule moduleId="cdtBuildSystem" version="4.0.0">
+ <project id="epics.null.695242225" name="epics"/>
+ </storageModule>
+ <storageModule moduleId="scannerConfiguration">
+ <autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+ <scannerConfigBuildInfo instanceId="0.1482250461">
+ <autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+ </scannerConfigBuildInfo>
+ </storageModule>
+ <storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
+</cproject>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>epics</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+ <triggers>clean,full,incremental,</triggers>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
+ <triggers>full,incremental,</triggers>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.cdt.core.cnature</nature>
+ <nature>org.eclipse.cdt.core.ccnature</nature>
+ <nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+ <nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+ </natures>
+</projectDescription>
--- /dev/null
+#Makefile at top of application tree
+TOP = .
+include $(TOP)/configure/CONFIG
+DIRS := $(DIRS) $(filter-out $(DIRS), configure)
+DIRS := $(DIRS) $(filter-out $(DIRS), $(wildcard *App))
+DIRS := $(DIRS) $(filter-out $(DIRS), $(wildcard iocBoot))
+
+define DIR_template
+ $(1)_DEPEND_DIRS = configure
+endef
+$(foreach dir, $(filter-out configure,$(DIRS)),$(eval $(call DIR_template,$(dir))))
+
+iocBoot_DEPEND_DIRS += $(filter %App,$(DIRS))
+
+include $(TOP)/configure/RULES_TOP
+
+
--- /dev/null
+# CONFIG - Load build configuration data
+#
+# Do not make changes to this file!
+
+# Allow user to override where the build rules come from
+RULES = $(EPICS_BASE)
+
+# RELEASE files point to other application tops
+include $(TOP)/configure/RELEASE
+-include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH).Common
+ifdef T_A
+-include $(TOP)/configure/RELEASE.Common.$(T_A)
+-include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH).$(T_A)
+endif
+
+CONFIG = $(RULES)/configure
+include $(CONFIG)/CONFIG
+
+# Override the Base definition:
+INSTALL_LOCATION = $(TOP)
+
+# CONFIG_SITE files contain other build configuration settings
+include $(TOP)/configure/CONFIG_SITE
+-include $(TOP)/configure/CONFIG_SITE.$(EPICS_HOST_ARCH).Common
+ifdef T_A
+ -include $(TOP)/configure/CONFIG_SITE.Common.$(T_A)
+ -include $(TOP)/configure/CONFIG_SITE.$(EPICS_HOST_ARCH).$(T_A)
+endif
+
--- /dev/null
+# CONFIG_SITE
+
+# Make any application-specific changes to the EPICS build
+# configuration variables in this file.
+#
+# Host/target specific settings can be specified in files named
+# CONFIG_SITE.$(EPICS_HOST_ARCH).Common
+# CONFIG_SITE.Common.$(T_A)
+# CONFIG_SITE.$(EPICS_HOST_ARCH).$(T_A)
+
+# CHECK_RELEASE controls the consistency checking of the support
+# applications pointed to by the RELEASE* files.
+# Normally CHECK_RELEASE should be set to YES.
+# Set CHECK_RELEASE to NO to disable checking completely.
+# Set CHECK_RELEASE to WARN to perform consistency checking but
+# continue building anyway if conflicts are found.
+CHECK_RELEASE = YES
+
+# Set this when you only want to compile this application
+# for a subset of the cross-compiled target architectures
+# that Base is built for.
+#CROSS_COMPILER_TARGET_ARCHS = vxWorks-68040
+
+# To install files into a location other than $(TOP) define
+# INSTALL_LOCATION here.
+#INSTALL_LOCATION=</path/name/to/install/top>
+
+# Set this when your IOC and the host use different paths
+# to access the application. This will be needed to boot
+# from a Microsoft FTP server or with some NFS mounts.
+# You must rebuild in the iocBoot directory for this to
+# take effect.
+#IOCS_APPL_TOP = </IOC/path/to/application/top>
--- /dev/null
+TOP=..
+
+include $(TOP)/configure/CONFIG
+
+TARGETS = $(CONFIG_TARGETS)
+CONFIGS += $(subst ../,,$(wildcard $(CONFIG_INSTALLS)))
+
+include $(TOP)/configure/RULES
--- /dev/null
+# RELEASE - Location of external support modules
+#
+# IF YOU MAKE ANY CHANGES to this file you must subsequently
+# do a "gnumake rebuild" in this application's top level
+# directory.
+#
+# The build process does not check dependencies against files
+# that are outside this application, thus you should do a
+# "gnumake rebuild" in the top level directory after EPICS_BASE
+# or any other external module pointed to below is rebuilt.
+#
+# Host- or target-specific settings can be given in files named
+# RELEASE.$(EPICS_HOST_ARCH).Common
+# RELEASE.Common.$(T_A)
+# RELEASE.$(EPICS_HOST_ARCH).$(T_A)
+#
+# This file should ONLY define paths to other support modules,
+# or include statements that pull in similar RELEASE files.
+# Build settings that are NOT module paths should appear in a
+# CONFIG_SITE file.
+
+TEMPLATE_TOP=$(EPICS_BASE)/templates/makeBaseApp/top
+
+# If using the sequencer, point SNCSEQ at its top directory:
+#SNCSEQ=$(EPICS_BASE)/../modules/soft/seq
+
+# EPICS_BASE usually appears last so other apps can override stuff:
+EPICS_BASE=/home/scs/EPICS/base-3-14-11
+
+# Set RULES here if you want to take build rules from somewhere
+# other than EPICS_BASE:
+#RULES=/path/to/epics/support/module/rules/x-y
--- /dev/null
+# RULES
+
+include $(CONFIG)/RULES
+
+# Library should be rebuilt because LIBOBJS may have changed.
+$(LIBNAME): ../Makefile
--- /dev/null
+#RULES.ioc
+include $(CONFIG)/RULES.ioc
--- /dev/null
+#RULES_DIRS
+include $(CONFIG)/RULES_DIRS
--- /dev/null
+#RULES_TOP
+include $(CONFIG)/RULES_TOP
+
--- /dev/null
+TOP = ..
+include $(TOP)/configure/CONFIG
+DIRS += $(wildcard *ioc*)
+DIRS += $(wildcard as*)
+include $(CONFIG)/RULES_DIRS
+
--- /dev/null
+TOP = ../..
+include $(TOP)/configure/CONFIG
+ARCH = linux-x86
+TARGETS = envPaths
+include $(TOP)/configure/RULES.ioc
--- /dev/null
+To start the ioc from this directory execute the command
+ ../../bin/linux-x86/<appname> st.cmd
+
+Alternatively make the st.cmd file directly executable with
+ chmod +x st.cmd
+and check the executable name on the first line of the st.cmd file
+
+You may need to change the name of the .dbd file given in the
+st.cmd's dbLoadDatabase() command before starting the ioc.
--- /dev/null
+epicsEnvSet("ARCH","linux-x86")
+epicsEnvSet("IOC","ioclxhadesdaq")
+epicsEnvSet("TOP","/home/scs/EPICS/apps/trb")
+epicsEnvSet("EPICS_BASE","/home/scs/EPICS/base-3-14-11")
+epicsEnvSet("EPICS_CA_MAX_ARRAY_BYTES","50000")
+epicsEnvSet("EPICS_TIMEZONE","MET::-60:032902:102502")
--- /dev/null
+#!../../bin/linux-x86/trb
+
+## You may have to change trb to something else
+## everywhere it appears in this file
+
+< envPaths
+
+cd ${TOP}
+
+## Register all support components
+dbLoadDatabase "dbd/trb.dbd"
+trb_registerRecordDeviceDriver pdbbase
+
+## Load record instances
+#dbLoadTemplate "db/user.substitutions"
+dbLoadRecords "db/dbExample1.db", "user=scs"
+dbLoadRecords "db/trbExample.db"
+dbLoadRecords "db/ctsScaler.db"
+dbLoadRecords "db/ctsRegister.db"
+dbLoadRecords "db/ctsBeamstruct.db"
+#dbLoadRecords "db/oepRead.db"
+#dbLoadRecords "db/oepVolt.db"
+
+## Set this to see messages from mySub
+var mySubDebug 0
+
+## Run this to trace the stages of iocInit
+#traceIocInit
+
+cd ${TOP}/iocBoot/${IOC}
+iocInit
+
+## Start any sequence programs
+#seq sncExample, "user=scsHost"
--- /dev/null
+TOP=../..
+include $(TOP)/configure/CONFIG
+#----------------------------------------
+# ADD MACRO DEFINITIONS AFTER THIS LINE
+
+#----------------------------------------------------
+# Optimization of db files using dbst (DEFAULT: NO)
+#DB_OPT = YES
+
+#----------------------------------------------------
+# Create and install (or just install)
+# databases, templates, substitutions like this
+DB += dbExample1.db
+DB += trbExample.db
+DB += oepRead.db
+DB += oepVolt.db
+DB += user.substitutions
+DB += ctsScaler.db
+DB += ctsRegister.db
+DB += ctsBeamstruct.db
+
+#----------------------------------------------------
+# If <anyname>.db template is not named <anyname>*.template add
+# <anyname>_TEMPLATE = <templatename>
+
+include $(TOP)/configure/RULES
+#----------------------------------------
+# ADD RULES AFTER THIS LINE
+
--- /dev/null
+record(calcout, "HAD:CTS:BEAM:Trigger")
+{
+ field(DESC, "Trigger on beam bit")
+ field(SCAN,".1 second")
+ field(INPA, "HAD:CTS:REG:0xa002:LOW.B4")
+ field(CALC, "A")
+ field(OOPT, "Transition To Non-zero")
+ field(OUT, "HAD:CTS:BEAM:Read.PROC")
+}
+record(calcout, "HAD:CTS:BEAM:TriggerOff")
+{
+ field(DESC, "Trigger on beam bit")
+ field(SCAN,".1 second")
+ field(INPA, "HAD:CTS:REG:0xa002:LOW.B4")
+ field(CALC, "!A")
+ field(OOPT, "Transition To Non-zero")
+ field(OUT, "HAD:CTS:BEAM:Sum.PROC")
+}
+record(calc, "HAD:CTS:WATCH:Up")
+{
+ field(DESC, "Trigger on beam bit")
+ field(SCAN,".1 second")
+ field(INPA, "HAD:CTS:WATCH:Up NPP")
+ field(CALC, "A+0.1")
+ field(PREC, "1")
+ field(FLNK, "HAD:CTS:WATCH:Trigger")
+}
+record(calcout, "HAD:CTS:WATCH:Trigger")
+{
+ field(DESC, "Trigger on beam bit")
+ field(SCAN,"Passive")
+ field(INPA, "HAD:CTS:WATCH:Down NPP")
+ field(CALC, "A>3")
+ field(OOPT, "When Non-zero")
+ field(OUT, "HAD:CTS:WATCH:Reset.PROC PP")
+}
+record(sub, "HAD:CTS:WATCH:Reset")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"WatchInit")
+ field(SNAM,"WatchReset")
+ field(INPA, "HAD:CTS:WATCH:Down")
+}
+record(aSub, "HAD:CTS:BEAM:Read")
+{
+ field(DESC, "Read trbnet Register multiple")
+# field(SCAN,"1 second")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbReadMem")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "0xa100")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "5000")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "0")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:BEAM:Array PP")
+ field(FTVA, "LONG")
+ field(NOVA, "5000")
+}
+record(waveform, "HAD:CTS:BEAM:Array")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "5000")
+ field(FTVL, "LONG")
+ field(FLNK, "HAD:CTS:BEAM:Array1")
+}
+record(subArray, "HAD:CTS:BEAM:Array1")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "0")
+ field(FLNK, "HAD:CTS:BEAM:Array2")
+}
+record(subArray, "HAD:CTS:BEAM:Array2")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "500")
+ field(FLNK, "HAD:CTS:BEAM:Array3")
+}
+record(subArray, "HAD:CTS:BEAM:Array3")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "1000")
+ field(FLNK, "HAD:CTS:BEAM:Array4")
+}
+record(subArray, "HAD:CTS:BEAM:Array4")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "1500")
+ field(FLNK, "HAD:CTS:BEAM:Array5")
+}
+record(subArray, "HAD:CTS:BEAM:Array5")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "2000")
+ field(FLNK, "HAD:CTS:BEAM:Array6")
+}
+record(subArray, "HAD:CTS:BEAM:Array6")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "2500")
+ field(FLNK, "HAD:CTS:BEAM:Array7")
+}
+record(subArray, "HAD:CTS:BEAM:Array7")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "3000")
+ field(FLNK, "HAD:CTS:BEAM:Array8")
+}
+record(subArray, "HAD:CTS:BEAM:Array8")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "3500")
+ field(FLNK, "HAD:CTS:BEAM:Array9")
+}
+record(subArray, "HAD:CTS:BEAM:Array9")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "4000")
+ field(FLNK, "HAD:CTS:BEAM:Array10")
+}
+record(subArray, "HAD:CTS:BEAM:Array10")
+{
+ field(DESC, "Addr")
+ field(DTYP, "Soft Channel")
+ field(SCAN,"Passive")
+ field(INP, "HAD:CTS:BEAM:Array.VAL")
+ field(NELM, "500")
+ field(MALM, "5000")
+ field(FTVL, "LONG")
+ field(INDX, "4500")
+}
--- /dev/null
+record(calcout, "HAD:CTS:REG:MUX:$(NN):Group")
+{
+ field(SCAN, "1 second")
+ field(INPA, "HAD:CTS:REG:0xa0c2:BYTE$(NN)")
+ field(CALC, "A/36")
+ field(OUT, "HAD:CTS:REG:MUX:$(NN):OUT:Group")
+}
+record(calcout, "HAD:CTS:REG:MUX:$(NN):Channel")
+{
+ field(SCAN, "1 second")
+ field(INPA, "HAD:CTS:REG:0xa0c2:BYTE$(NN)")
+ field(CALC, "(A%36)")
+ field(OUT, "HAD:CTS:REG:MUX:$(NN):OUT:Channel")
+}
+record(longout, "HAD:CTS:REG:MUX:$(NN):OUT:Group")
+{
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:MUX:CALC:BYTE$(NN)")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(longout, "HAD:CTS:REG:MUX:$(NN):OUT:Channel")
+{
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:MUX:CALC:BYTE$(NN)")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(calcout, "HAD:CTS:REG:MUX:CALC:BYTE$(NN)")
+{
+ field(INPA, "HAD:CTS:REG:MUX:$(NN):OUT:Group")
+ field(INPB, "HAD:CTS:REG:MUX:$(NN):OUT:Channel")
+ field(CALC, "(A*36)+B")
+ field(OUT, "HAD:CTS:REG:0xa0c2:OUT:BYTE$(NN) PP")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit4")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):BYTE0 PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):BYTE1 PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(OUTC, "HAD:CTS:REG:$(NN):BYTE2 PP")
+ field(FTVC, "LONG")
+ field(NOVC, "1")
+ field(OUTD, "HAD:CTS:REG:$(NN):BYTE3 PP")
+ field(FTVD, "LONG")
+ field(NOVD, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE0")
+{
+ field(DESC, "byte 0")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE0 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE1")
+{
+ field(DESC, "byte 1")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE1 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE2")
+{
+ field(DESC, "byte 2")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE2 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE3")
+{
+ field(DESC, "byte 3")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE3 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE0")
+{
+ field(DESC, "byte 0")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE1")
+{
+ field(DESC, "byte 1")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE2")
+{
+ field(DESC, "byte 2")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE3")
+{
+ field(DESC, "byte 3")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT")
+{
+ field(DESC, "UnSplit 4 8bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit4")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:BYTE0")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:BYTE1")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT:BYTE2")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "HAD:CTS:REG:$(NN):OUT:BYTE3")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit4")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):BYTE0 PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):BYTE1 PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(OUTC, "HAD:CTS:REG:$(NN):BYTE2 PP")
+ field(FTVC, "LONG")
+ field(NOVC, "1")
+ field(OUTD, "HAD:CTS:REG:$(NN):BYTE3 PP")
+ field(FTVD, "LONG")
+ field(NOVD, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE0")
+{
+ field(DESC, "byte 0")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE0 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE0:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):BYTE0:AI")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):BYTE0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE0:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):BYTE0:MOV")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):BYTE0:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):BYTE0:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):BYTE0:AO")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE0 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE1")
+{
+ field(DESC, "byte 1")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE1 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE1:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):BYTE1:AI")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):BYTE1")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE1:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):BYTE1:MOV")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):BYTE1:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):BYTE1:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):BYTE1:AO")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE1 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE2")
+{
+ field(DESC, "byte 2")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE2 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE2:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):BYTE2:AI")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):BYTE2")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE2:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):BYTE2:MOV")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):BYTE2:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):BYTE2:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):BYTE2:AO")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE2 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+record(longout, "HAD:CTS:REG:$(NN):BYTE3")
+{
+ field(DESC, "byte 3")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE3 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE3:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):BYTE3:AI")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):BYTE3")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):BYTE3:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):BYTE3:MOV")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):BYTE3:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):BYTE3:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):BYTE3:AO")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:BYTE3 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE0")
+{
+ field(DESC, "byte 0")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE1")
+{
+ field(DESC, "byte 1")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE2")
+{
+ field(DESC, "byte 2")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:BYTE3")
+{
+ field(DESC, "byte 3")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT")
+{
+ field(DESC, "UnSplit 4 8bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit4")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:BYTE0")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:BYTE1")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT:BYTE2")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "HAD:CTS:REG:$(NN):OUT:BYTE3")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):FAN")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):FAN")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN).VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):MDCB.VAL PP")
+ field(OUTB, "HAD:CTS:REG:$(NN):MDCA.VAL PP")
+ field(OUTC, "HAD:CTS:REG:$(NN):TGW.VAL PP")
+}
+record(longout, "HAD:CTS:REG:$(NN):MDCB")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):CALC:MDCB")
+}
+record(calcout, "HAD:CTS:REG:$(NN):CALC:MDCB")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(INPA, "HAD:CTS:REG:$(NN):MDCB")
+ field(CALC, "(A>>12)&31")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:MDCB NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:MDCB")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):CALC")
+ field(DRVH, "31")
+}
+record(longout, "HAD:CTS:REG:$(NN):MDCA")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):CALC:MDCA")
+}
+record(calcout, "HAD:CTS:REG:$(NN):CALC:MDCA")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(INPA, "HAD:CTS:REG:$(NN):MDCA")
+ field(CALC, "(A>>17)&31")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:MDCA NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:MDCA")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):CALC")
+ field(DRVH, "31")
+}
+record(longout, "HAD:CTS:REG:$(NN):TGW")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):CALC:TGW")
+}
+record(calcout, "HAD:CTS:REG:$(NN):CALC:TGW")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(INPA, "HAD:CTS:REG:$(NN):TGW")
+ field(CALC, "(A>>28)&15")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:TGW NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:TGW")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):CALC")
+ field(DRVH, "15")
+}
+record(calcout, "HAD:CTS:REG:$(NN):CALC")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:MDCB")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:MDCA")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT:TGW")
+ field(CALC, "(A<<12)|(B<<17)|(C<<28)")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT PP")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):LOW PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):HIGH PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT1")
+}
+record(mbbiDirect, "HAD:CTS:REG:$(NN):LOW")
+{
+ field(DESC, "low 16 bits")
+ field(INP, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):MOV:LOW")
+}
+record(mbbiDirect, "HAD:CTS:REG:$(NN):HIGH")
+{
+ field(DESC, "high 16 bits")
+ field(INP, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):MOV:HIGH")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):MOV:LOW")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):LOW.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT:LOW.VAL NPP")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):MOV:HIGH")
+{
+ field(DESC, "high 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):HIGH.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT:HIGH.VAL NPP")
+}
+record(mbboDirect, "HAD:CTS:REG:$(NN):OUT:LOW")
+{
+ field(DESC, "low 16 bits")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(mbboDirect, "HAD:CTS:REG:$(NN):OUT:HIGH")
+{
+ field(DESC, "high 16 bits")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT")
+{
+ field(DESC, "UnSplit 16bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:LOW")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:HIGH")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT1")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit8")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB0 PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):NIBB1 PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(OUTC, "HAD:CTS:REG:$(NN):NIBB2 PP")
+ field(FTVC, "LONG")
+ field(NOVC, "1")
+ field(OUTD, "HAD:CTS:REG:$(NN):NIBB3 PP")
+ field(FTVD, "LONG")
+ field(NOVD, "1")
+ field(OUTE, "HAD:CTS:REG:$(NN):NIBB4 PP")
+ field(FTVE, "LONG")
+ field(NOVE, "1")
+ field(OUTF, "HAD:CTS:REG:$(NN):NIBB5 PP")
+ field(FTVF, "LONG")
+ field(NOVF, "1")
+ field(OUTG, "HAD:CTS:REG:$(NN):NIBB6 PP")
+ field(FTVG, "LONG")
+ field(NOVG, "1")
+ field(OUTH, "HAD:CTS:REG:$(NN):NIBB7 PP")
+ field(FTVH, "LONG")
+ field(NOVH, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB0")
+{
+ field(DESC, "nibble 0")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB0 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB1")
+{
+ field(DESC, "nibble 1")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB1 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB2")
+{
+ field(DESC, "nibble 2")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB2 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB3")
+{
+ field(DESC, "nibble 3")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB3 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB4")
+{
+ field(DESC, "nibble 4")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB4 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB5")
+{
+ field(DESC, "nibble 5")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB5 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB6")
+{
+ field(DESC, "nibble 6")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB6 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB7")
+{
+ field(DESC, "nibble 7")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB7 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB0")
+{
+ field(DESC, "nibble 0")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB1")
+{
+ field(DESC, "nibble 1")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB2")
+{
+ field(DESC, "nibble 2")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB3")
+{
+ field(DESC, "nibble 3")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB4")
+{
+ field(DESC, "nibble 4")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB5")
+{
+ field(DESC, "nibble 5")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB6")
+{
+ field(DESC, "nibble 6")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB7")
+{
+ field(DESC, "nibble 7")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT1")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT1")
+{
+ field(DESC, "UnSplit 8 4bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit8")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:NIBB0")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:NIBB1")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT:NIBB2")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "HAD:CTS:REG:$(NN):OUT:NIBB3")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(INPE, "HAD:CTS:REG:$(NN):OUT:NIBB4")
+ field(FTE, "LONG")
+ field(NOE, "1")
+ field(INPF, "HAD:CTS:REG:$(NN):OUT:NIBB5")
+ field(FTF, "LONG")
+ field(NOF, "1")
+ field(INPG, "HAD:CTS:REG:$(NN):OUT:NIBB6")
+ field(FTG, "LONG")
+ field(NOG, "1")
+ field(INPH, "HAD:CTS:REG:$(NN):OUT:NIBB7")
+ field(FTH, "LONG")
+ field(NOH, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
+
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):LOW PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):HIGH PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+}
+record(mbbiDirect, "HAD:CTS:REG:$(NN):LOW")
+{
+ field(DESC, "low 16 bits")
+ field(INP, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):MOV:LOW")
+}
+record(mbbiDirect, "HAD:CTS:REG:$(NN):HIGH")
+{
+ field(DESC, "high 16 bits")
+ field(INP, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):MOV:HIGH")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):MOV:LOW")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):LOW.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT:LOW.VAL NPP")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):MOV:HIGH")
+{
+ field(DESC, "high 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):HIGH.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT:HIGH.VAL NPP")
+}
+record(mbboDirect, "HAD:CTS:REG:$(NN):OUT:LOW")
+{
+ field(DESC, "low 16 bits")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(mbboDirect, "HAD:CTS:REG:$(NN):OUT:HIGH")
+{
+ field(DESC, "high 16 bits")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT")
+{
+ field(DESC, "UnSplit 16bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:LOW")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:HIGH")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
+
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit8")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB0 PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):NIBB1 PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(OUTC, "HAD:CTS:REG:$(NN):NIBB2 PP")
+ field(FTVC, "LONG")
+ field(NOVC, "1")
+ field(OUTD, "HAD:CTS:REG:$(NN):NIBB3 PP")
+ field(FTVD, "LONG")
+ field(NOVD, "1")
+ field(OUTE, "HAD:CTS:REG:$(NN):NIBB4 PP")
+ field(FTVE, "LONG")
+ field(NOVE, "1")
+ field(OUTF, "HAD:CTS:REG:$(NN):NIBB5 PP")
+ field(FTVF, "LONG")
+ field(NOVF, "1")
+ field(OUTG, "HAD:CTS:REG:$(NN):NIBB6 PP")
+ field(FTVG, "LONG")
+ field(NOVG, "1")
+ field(OUTH, "HAD:CTS:REG:$(NN):NIBB7 PP")
+ field(FTVH, "LONG")
+ field(NOVH, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB0")
+{
+ field(DESC, "nibble 0")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB0 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB1")
+{
+ field(DESC, "nibble 1")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB1 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB2")
+{
+ field(DESC, "nibble 2")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB2 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB3")
+{
+ field(DESC, "nibble 3")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB3 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB4")
+{
+ field(DESC, "nibble 4")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB4 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB5")
+{
+ field(DESC, "nibble 5")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB5 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB6")
+{
+ field(DESC, "nibble 6")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB6 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB7")
+{
+ field(DESC, "nibble 7")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB7 NPP")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB0")
+{
+ field(DESC, "nibble 0")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB1")
+{
+ field(DESC, "nibble 1")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB2")
+{
+ field(DESC, "nibble 2")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB3")
+{
+ field(DESC, "nibble 3")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB4")
+{
+ field(DESC, "nibble 4")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB5")
+{
+ field(DESC, "nibble 5")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB6")
+{
+ field(DESC, "nibble 6")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB7")
+{
+ field(DESC, "nibble 7")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT")
+{
+ field(DESC, "UnSplit 8 4bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit8")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:NIBB0")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:NIBB1")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT:NIBB2")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "HAD:CTS:REG:$(NN):OUT:NIBB3")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(INPE, "HAD:CTS:REG:$(NN):OUT:NIBB4")
+ field(FTE, "LONG")
+ field(NOE, "1")
+ field(INPF, "HAD:CTS:REG:$(NN):OUT:NIBB5")
+ field(FTF, "LONG")
+ field(NOF, "1")
+ field(INPG, "HAD:CTS:REG:$(NN):OUT:NIBB6")
+ field(FTG, "LONG")
+ field(NOG, "1")
+ field(INPH, "HAD:CTS:REG:$(NN):OUT:NIBB7")
+ field(FTH, "LONG")
+ field(NOH, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):SPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):SPLIT")
+{
+ field(DESC, "Split 32bit into 2 mbbo")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegSplit8")
+ field(INPA, "HAD:CTS:REG:$(NN)")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB0 PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:CTS:REG:$(NN):NIBB1 PP")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(OUTC, "HAD:CTS:REG:$(NN):NIBB2 PP")
+ field(FTVC, "LONG")
+ field(NOVC, "1")
+ field(OUTD, "HAD:CTS:REG:$(NN):NIBB3 PP")
+ field(FTVD, "LONG")
+ field(NOVD, "1")
+ field(OUTE, "HAD:CTS:REG:$(NN):NIBB4 PP")
+ field(FTVE, "LONG")
+ field(NOVE, "1")
+ field(OUTF, "HAD:CTS:REG:$(NN):NIBB5 PP")
+ field(FTVF, "LONG")
+ field(NOVF, "1")
+ field(OUTG, "HAD:CTS:REG:$(NN):NIBB6 PP")
+ field(FTVG, "LONG")
+ field(NOVG, "1")
+ field(OUTH, "HAD:CTS:REG:$(NN):NIBB7 PP")
+ field(FTVH, "LONG")
+ field(NOVH, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB0")
+{
+ field(DESC, "nibble 0")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB0 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB0:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB0:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB0:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB0:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB0:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB0:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB0:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB0 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+record(longout, "HAD:CTS:REG:$(NN):NIBB1")
+{
+ field(DESC, "nibble 1")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB1 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB1:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB1:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB1")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB1:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB1:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB1:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB1:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB1:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB1 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):NIBB2")
+{
+ field(DESC, "nibble 2")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB2 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB2:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB2:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB2")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB2:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB2:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB2:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB2:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB2:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB2 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):NIBB3")
+{
+ field(DESC, "nibble 3")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB3 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB3:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB3:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB3")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB3:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB3:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB3:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB3:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB3:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB3 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):NIBB4")
+{
+ field(DESC, "nibble 4")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB4 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB4:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB4:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB4")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB4:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB4:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB4:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB4:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB4:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB4 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):NIBB5")
+{
+ field(DESC, "nibble 5")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB5 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB5:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB5:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB5")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB5:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB5:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB5:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB5:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB5:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB5 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):NIBB6")
+{
+ field(DESC, "nibble 6")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB6 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB6:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB6:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB6")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB6:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB6:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB6:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB6:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB6:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB6 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):NIBB7")
+{
+ field(DESC, "nibble 7")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB7 NPP")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB7:AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):NIBB7:AI")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN):NIBB7")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):NIBB7:MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):NIBB7:MOV")
+{
+ field(DESC, "nibb0")
+ field(DOL, "HAD:CTS:REG:$(NN):NIBB7:AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):NIBB7:AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):NIBB7:AO")
+{
+ field(DESC, "nibb0")
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT:NIBB7 PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB0")
+{
+ field(DESC, "nibble 0")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB1")
+{
+ field(DESC, "nibble 1")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB2")
+{
+ field(DESC, "nibble 2")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB3")
+{
+ field(DESC, "nibble 3")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB4")
+{
+ field(DESC, "nibble 4")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB5")
+{
+ field(DESC, "nibble 5")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB6")
+{
+ field(DESC, "nibble 6")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT:NIBB7")
+{
+ field(DESC, "nibble 7")
+ field(DRVH, "$(DDHH)")
+ field(OUT, "0")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+ field(FLNK, "HAD:CTS:REG:$(NN):UNSPLIT")
+}
+record(aSub, "HAD:CTS:REG:$(NN):UNSPLIT")
+{
+ field(DESC, "UnSplit 8 4bit into 1 long")
+ field(INAM,"ctsRegInit")
+ field(SNAM,"ctsRegUnsplit8")
+ field(INPA, "HAD:CTS:REG:$(NN):OUT:NIBB0")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:CTS:REG:$(NN):OUT:NIBB1")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT:NIBB2")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "HAD:CTS:REG:$(NN):OUT:NIBB3")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(INPE, "HAD:CTS:REG:$(NN):OUT:NIBB4")
+ field(FTE, "LONG")
+ field(NOE, "1")
+ field(INPF, "HAD:CTS:REG:$(NN):OUT:NIBB5")
+ field(FTF, "LONG")
+ field(NOF, "1")
+ field(INPG, "HAD:CTS:REG:$(NN):OUT:NIBB6")
+ field(FTG, "LONG")
+ field(NOG, "1")
+ field(INPH, "HAD:CTS:REG:$(NN):OUT:NIBB7")
+ field(FTH, "LONG")
+ field(NOH, "1")
+ field(OUTA, "HAD:CTS:REG:$(NN):OUT PP")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+record(aSub, "HAD:CTS:$(NAM):Read")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"1 second")
+# field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbReadMem")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "$(MM)")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "0")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:$(NAM):Array PP")
+ field(FTVA, "LONG")
+ field(NOVA, "$(MM)")
+ field(FLNK, "HAD:CTS:$(NAM):Read1")
+}
+record(waveform, "HAD:CTS:$(NAM):Array")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "$(MM)")
+ field(FTVL, "LONG")
+}
+record(aSub, "HAD:CTS:$(NAM):Read1")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "HAD:CTS:$(NAM):Array")
+ field(FTA, "LONG")
+ field(NOA, "$(MM)")
+ field(INPC, "0")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "16")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:REG:0xa0c0 PP")
+ field(OUTB, "HAD:CTS:REG:0xa0c1 PP")
+ field(OUTC, "HAD:CTS:REG:0xa0c2 PP")
+ field(OUTD, "HAD:CTS:REG:0xa0c3 PP")
+ field(OUTE, "HAD:CTS:REG:0xa0c4 PP")
+ field(OUTF, "HAD:CTS:REG:0xa0c5 PP")
+ field(OUTG, "HAD:CTS:REG:0xa0c6 PP")
+ field(OUTH, "HAD:CTS:REG:0xa0c7 PP")
+ field(OUTI, "HAD:CTS:REG:0xa0c8 PP")
+ field(OUTJ, "HAD:CTS:REG:0xa0c9 PP")
+ field(OUTK, "HAD:CTS:REG:0xa0ca PP")
+ field(OUTL, "HAD:CTS:REG:0xa0cb PP")
+ field(OUTM, "HAD:CTS:REG:0xa0cc PP")
+ field(OUTN, "HAD:CTS:REG:0xa0cd PP")
+ field(OUTO, "HAD:CTS:REG:0xa0ce PP")
+ field(OUTP, "HAD:CTS:REG:0xa0cf PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "HAD:CTS:$(NAM):Read2")
+}
+record(aSub, "HAD:CTS:$(NAM):Read2")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "HAD:CTS:$(NAM):Array")
+ field(FTA, "LONG")
+ field(NOA, "$(MM)")
+ field(INPC, "16")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "16")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:REG:0xa0d0 PP")
+ field(OUTB, "HAD:CTS:REG:0xa0d1 PP")
+ field(OUTC, "HAD:CTS:REG:0xa0d2 PP")
+ field(OUTD, "HAD:CTS:REG:0xa0d3 PP")
+ field(OUTE, "HAD:CTS:REG:0xa0d4 PP")
+ field(OUTF, "HAD:CTS:REG:0xa0d5 PP")
+ field(OUTG, "HAD:CTS:REG:0xa0d6 PP")
+ field(OUTH, "HAD:CTS:REG:0xa0d7 PP")
+ field(OUTI, "HAD:CTS:REG:0xa0d8 PP")
+ field(OUTJ, "HAD:CTS:REG:0xa0d9 PP")
+ field(OUTK, "HAD:CTS:REG:0xa0da PP")
+ field(OUTL, "HAD:CTS:REG:0xa0db PP")
+ field(OUTM, "HAD:CTS:REG:0xa0dc PP")
+ field(OUTN, "HAD:CTS:REG:0xa0dd PP")
+ field(OUTO, "HAD:CTS:REG:0xa0de PP")
+ field(OUTP, "HAD:CTS:REG:0xa0df PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "HAD:CTS:$(NAM):Read3")
+}
+record(aSub, "HAD:CTS:$(NAM):Read3")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "HAD:CTS:$(NAM):Array")
+ field(FTA, "LONG")
+ field(NOA, "$(MM)")
+ field(INPC, "32")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "16")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:REG:0xa0e0 PP")
+ field(OUTB, "HAD:CTS:REG:0xa0e1 PP")
+ field(OUTC, "HAD:CTS:REG:0xa0e2 PP")
+ field(OUTD, "HAD:CTS:REG:0xa0e3 PP")
+ field(OUTE, "HAD:CTS:REG:0xa0e4 PP")
+ field(OUTF, "HAD:CTS:REG:0xa0e5 PP")
+ field(OUTG, "HAD:CTS:REG:0xa0e6 PP")
+ field(OUTH, "HAD:CTS:REG:0xa0e7 PP")
+ field(OUTI, "HAD:CTS:REG:0xa0e8 PP")
+ field(OUTJ, "HAD:CTS:REG:0xa0e9 PP")
+ field(OUTK, "HAD:CTS:REG:0xa0ea PP")
+ field(OUTL, "HAD:CTS:REG:0xa0eb PP")
+ field(OUTM, "HAD:CTS:REG:0xa0ec PP")
+ field(OUTN, "HAD:CTS:REG:0xa0ed PP")
+ field(OUTO, "HAD:CTS:REG:0xa0ee PP")
+ field(OUTP, "HAD:CTS:REG:0xa0ef PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "HAD:CTS:WATCH:Down")
+}
+record(calcout, "HAD:CTS:WATCH:Down")
+{
+ field(DESC, "Trigger on beam bit")
+ field(SCAN,"Passive")
+ field(INPA, "HAD:CTS:WATCH:Up NPP")
+ field(CALC, "A>0?A-1:0")
+ field(OOPT, "Every Time")
+ field(OUT, "HAD:CTS:WATCH:Up.VAL NPP")
+ field(PREC, "1")
+}
--- /dev/null
+record(aSub, "HAD:CTS:$(NAM):Read")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"1 second")
+# field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbReadMem")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "$(MM)")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "0")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:$(NAM):Array PP")
+ field(FTVA, "LONG")
+ field(NOVA, "$(MM)")
+ field(FLNK, "HAD:CTS:$(NAM):Read1")
+}
+record(waveform, "HAD:CTS:$(NAM):Array")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "$(MM)")
+ field(FTVL, "LONG")
+}
+record(aSub, "HAD:CTS:$(NAM):Read1")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "HAD:CTS:$(NAM):Array")
+ field(FTA, "LONG")
+ field(NOA, "$(MM)")
+ field(INPC, "0")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "8")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:CTS:REG:0xa000 PP")
+ field(OUTB, "HAD:CTS:REG:0xa001 PP")
+ field(OUTC, "HAD:CTS:REG:0xa002 PP")
+ field(OUTD, "HAD:CTS:REG:0xa003 PP")
+ field(OUTE, "HAD:CTS:REG:0xa004 PP")
+ field(OUTF, "HAD:CTS:REG:0xa005 PP")
+ field(OUTG, "HAD:CTS:REG:0xa006 PP")
+ field(OUTH, "HAD:CTS:REG:0xa007 PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(NOVA, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT")
+}
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:REG:$(NN)")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT")
+ field(FLNK, "HAD:CTS:REG:$(NN):AI")
+}
+record(ai,"HAD:CTS:REG:$(NN):AI")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(INP, "HAD:CTS:REG:$(NN)")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(FLNK, "HAD:CTS:REG:$(NN):MOV")
+ field(PREC, "$(PREC)")
+}
+record(dfanout, "HAD:CTS:REG:$(NN):MOV")
+{
+ field(DESC, "low 16 bits")
+ field(DOL, "HAD:CTS:REG:$(NN):AI.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:REG:$(NN):AO.VAL NPP")
+}
+record(ao,"HAD:CTS:REG:$(NN):AO")
+{
+ field(DTYP, "Raw Soft Channel")
+ field(OUT, "HAD:CTS:REG:$(NN):OUT PP")
+# field(OUT, "0")
+ field(LINR, "SLOPE")
+ field(ESLO, "$(ESLO)")
+ field(EOFF, "$(EOFF)")
+ field(EGU, "$(EGU)")
+ field(PREC, "$(PREC)")
+}
+
+record(longout, "HAD:CTS:REG:$(NN):OUT")
+{
+ field(DESC, "Read cts register $(NN) ")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:REG:$(NN):Write")
+ field(UDF, "0")
+ field(STAT, "NO_ALARM")
+ field(SEVR, "NO_ALARM")
+}
+record(aSub, "HAD:CTS:REG:$(NN):Write")
+{
+ field(DESC, "Write CTS Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "$(NN)")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:CTS:REG:$(NN):OUT")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
--- /dev/null
+file ctsRegRead.template {
+{NAM=CTSALL, NN=0xa0c0, MM=48}
+}
+file ctsRegRead1.template {
+{NAM=CTSALL1, NN=0xa000, MM=8}
+}
+file ctsRegCombi.template {
+# Inputs
+{NN=0xa0c0}
+}
+file ctsRegHiLo.template {
+# Inputs
+{NN=0xa000}
+{NN=0xa002}
+{NN=0xa0c3}
+{NN=0xa0c4}
+{NN=0xa0c5}
+{NN=0xa0c7}
+}
+file ctsRegByte.template {
+# Inputs
+{NN=0xa0c2}
+}
+file ctsRegByteScaled.template {
+# Inputs
+{NN=0xa0e5, DDHH=255, ESLO=5., EOFF=0., EGU=ns, PREC=0}
+{NN=0xa0e6, DDHH=255, ESLO=5., EOFF=0., EGU=ns, PREC=0}
+{NN=0xa0e7, DDHH=255, ESLO=5., EOFF=0., EGU=ns, PREC=0}
+}
+file ctsRegNibble.template {
+# Inputs
+{NN=0xa0c9, DDHH=15}
+{NN=0xa0ca, DDHH=15}
+{NN=0xa0cb, DDHH=15}
+{NN=0xa0de, DDHH=15}
+}
+file ctsRegNibbleScaled.template {
+# Inputs
+{NN=0xa0d1, DDHH=8, ESLO=1.25, EOFF=0., EGU=ns, PREC=2}
+{NN=0xa0d2, DDHH=8, ESLO=1.25, EOFF=0., EGU=ns, PREC=2}
+{NN=0xa0d3, DDHH=8, ESLO=1.25, EOFF=0., EGU=ns, PREC=2}
+{NN=0xa0d4, DDHH=8, ESLO=1.25, EOFF=0., EGU=ns, PREC=2}
+{NN=0xa0d5, DDHH=8, ESLO=1.25, EOFF=0., EGU=ns, PREC=2}
+{NN=0xa0e8, DDHH=15, ESLO=4., EOFF=5., EGU=ns, PREC=0}
+{NN=0xa0e9, DDHH=15, ESLO=4., EOFF=5., EGU=ns, PREC=0}
+{NN=0xa0ea, DDHH=15, ESLO=4., EOFF=5., EGU=ns, PREC=0}
+{NN=0xa0eb, DDHH=15, ESLO=4., EOFF=5., EGU=ns, PREC=0}
+{NN=0xa0ec, DDHH=15, ESLO=4., EOFF=5., EGU=ns, PREC=0}
+}
+file ctsRegC1.template {
+{NN=0xa0c1}
+}
+file ctsRegSimple.template {
+# Inputs
+{NN=0xa001}
+{NN=0xa003}
+{NN=0xa004}
+{NN=0xa005}
+{NN=0xa006}
+{NN=0xa007}
+{NN=0xa0cc}
+{NN=0xa0cd}
+{NN=0xa0ce}
+{NN=0xa0cf}
+{NN=0xa0d0}
+{NN=0xa0d6}
+{NN=0xa0d7}
+{NN=0xa0d8}
+{NN=0xa0e3}
+{NN=0xa0e4}
+{NN=0xa0ed}
+{NN=0xa0ee}
+{NN=0xa0ef}
+}
+file ctsRegSimpleScaled.template {
+# Inputs
+{NN=0xa0c6, ESLO=1.E-04, EOFF=0., EGU=ms, PREC=3}
+{NN=0xa0c8, ESLO=1.E-04, EOFF=0., EGU=ms, PREC=3}
+{NN=0xa0d9, ESLO=1.E-04, EOFF=0., EGU=ms, PREC=3}
+{NN=0xa0da, ESLO=1.E-04, EOFF=0., EGU=ms, PREC=3}
+{NN=0xa0db, ESLO=1.E-04, EOFF=0., EGU=ms, PREC=3}
+{NN=0xa0dc, ESLO=1.E-04, EOFF=0., EGU=ms, PREC=3}
+{NN=0xa0dd, ESLO=1.E-07, EOFF=0., EGU=s, PREC=1}
+}
+file ctsMux.template {
+{NN=0}
+{NN=1}
+}
--- /dev/null
+file ctsScalerRead.template {
+{PRE=HAD:CTS:SCAL:}
+
+}
+file ctsScalerSingle.template {
+# Inputs
+{NN=I:0, AA=0x0003, RR=0xa008}
+{NN=I:1, AA=0x0003, RR=0xa009}
+{NN=I:2, AA=0x0003, RR=0xa00a}
+{NN=I:3, AA=0x0003, RR=0xa00b}
+{NN=I:4, AA=0x0003, RR=0xa00c}
+{NN=I:5, AA=0x0003, RR=0xa00d}
+{NN=I:6, AA=0x0003, RR=0xa00e}
+{NN=I:7, AA=0x0003, RR=0xa00f}
+{NN=I:8, AA=0x0003, RR=0xa010}
+{NN=I:9, AA=0x0003, RR=0xa011}
+{NN=I:10, AA=0x0003, RR=0xa012}
+{NN=I:11, AA=0x0003, RR=0xa013}
+{NN=I:12, AA=0x0003, RR=0xa014}
+{NN=I:13, AA=0x0003, RR=0xa015}
+{NN=I:14, AA=0x0003, RR=0xa016}
+{NN=I:15, AA=0x0003, RR=0xa017}
+{NN=I:16, AA=0x0003, RR=0xa018}
+{NN=I:17, AA=0x0003, RR=0xa019}
+{NN=I:18, AA=0x0003, RR=0xa01a}
+{NN=I:19, AA=0x0003, RR=0xa01b}
+{NN=I:20, AA=0x0003, RR=0xa01c}
+{NN=I:21, AA=0x0003, RR=0xa01d}
+{NN=I:22, AA=0x0003, RR=0xa01e}
+{NN=I:23, AA=0x0003, RR=0xa01f}
+{NN=I:24, AA=0x0003, RR=0xa020}
+{NN=I:25, AA=0x0003, RR=0xa021}
+{NN=I:26, AA=0x0003, RR=0xa022}
+{NN=I:27, AA=0x0003, RR=0xa023}
+{NN=I:28, AA=0x0003, RR=0xa024}
+{NN=I:29, AA=0x0003, RR=0xa025}
+{NN=I:30, AA=0x0003, RR=0xa026}
+{NN=I:31, AA=0x0003, RR=0xa027}
+{NN=I:32, AA=0x0003, RR=0xa028}
+{NN=I:33, AA=0x0003, RR=0xa029}
+{NN=I:34, AA=0x0003, RR=0xa02a}
+{NN=I:35, AA=0x0003, RR=0xa02b}
+# Downscaled
+{NN=D:0, AA=0x0003, RR=0xa02c}
+{NN=D:1, AA=0x0003, RR=0xa02d}
+{NN=D:2, AA=0x0003, RR=0xa02e}
+{NN=D:3, AA=0x0003, RR=0xa02f}
+{NN=D:4, AA=0x0003, RR=0xa030}
+{NN=D:5, AA=0x0003, RR=0xa031}
+{NN=D:6, AA=0x0003, RR=0xa032}
+{NN=D:7, AA=0x0003, RR=0xa033}
+{NN=D:8, AA=0x0003, RR=0xa034}
+{NN=D:9, AA=0x0003, RR=0xa035}
+{NN=D:10, AA=0x0003, RR=0xa036}
+{NN=D:11, AA=0x0003, RR=0xa037}
+{NN=D:12, AA=0x0003, RR=0xa038}
+{NN=D:13, AA=0x0003, RR=0xa039}
+{NN=D:14, AA=0x0003, RR=0xa03a}
+{NN=D:15, AA=0x0003, RR=0xa03b}
+{NN=D:16, AA=0x0003, RR=0xa03c}
+{NN=D:17, AA=0x0003, RR=0xa03d}
+{NN=D:18, AA=0x0003, RR=0xa03e}
+# Accepted
+{NN=A:0, AA=0x0003, RR=0xa03f}
+{NN=A:1, AA=0x0003, RR=0xa040}
+{NN=A:2, AA=0x0003, RR=0xa041}
+{NN=A:3, AA=0x0003, RR=0xa042}
+{NN=A:4, AA=0x0003, RR=0xa043}
+{NN=A:5, AA=0x0003, RR=0xa044}
+{NN=A:6, AA=0x0003, RR=0xa045}
+{NN=A:7, AA=0x0003, RR=0xa046}
+{NN=A:8, AA=0x0003, RR=0xa047}
+{NN=A:9, AA=0x0003, RR=0xa048}
+{NN=A:10, AA=0x0003, RR=0xa049}
+{NN=A:11, AA=0x0003, RR=0xa04a}
+{NN=A:12, AA=0x0003, RR=0xa04b}
+{NN=A:13, AA=0x0003, RR=0xa04c}
+{NN=A:14, AA=0x0003, RR=0xa04d}
+{NN=A:15, AA=0x0003, RR=0xa04e}
+{NN=A:16, AA=0x0003, RR=0xa04f}
+{NN=A:17, AA=0x0003, RR=0xa050}
+{NN=A:18, AA=0x0003, RR=0xa051}
+# coincident
+{NN=B:0, AA=0x0003, RR=0xa052}
+{NN=B:1, AA=0x0003, RR=0xa053}
+{NN=B:2, AA=0x0003, RR=0xa054}
+{NN=B:3, AA=0x0003, RR=0xa055}
+{NN=B:4, AA=0x0003, RR=0xa056}
+{NN=B:5, AA=0x0003, RR=0xa057}
+{NN=B:6, AA=0x0003, RR=0xa058}
+{NN=B:7, AA=0x0003, RR=0xa059}
+{NN=B:8, AA=0x0003, RR=0xa05a}
+{NN=B:9, AA=0x0003, RR=0xa05b}
+{NN=B:10, AA=0x0003, RR=0xa05c}
+{NN=B:11, AA=0x0003, RR=0xa05d}
+{NN=B:12, AA=0x0003, RR=0xa05e}
+{NN=B:13, AA=0x0003, RR=0xa05f}
+{NN=B:14, AA=0x0003, RR=0xa060}
+{NN=B:15, AA=0x0003, RR=0xa061}
+{NN=B:16, AA=0x0003, RR=0xa062}
+}
--- /dev/null
+record(aSub, "$(PRE)Read0")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"1 second")
+# field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbReadMem")
+ field(INPA, "0x0003")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "0xa008")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "91")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "0")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "$(PRE)Scalerarray PP")
+ field(FTVA, "LONG")
+ field(NOVA, "91")
+ field(FLNK, "$(PRE)Read1")
+}
+record(waveform, "$(PRE)Scalerarray")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "91")
+ field(FTVL, "LONG")
+}
+record(aSub, "$(PRE)Read1")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "$(PRE)Scalerarray")
+ field(FTA, "LONG")
+ field(NOA, "91")
+ field(INPC, "0")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "18")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "$(PRE)I:0 PP")
+ field(OUTB, "$(PRE)I:1 PP")
+ field(OUTC, "$(PRE)I:2 PP")
+ field(OUTD, "$(PRE)I:3 PP")
+ field(OUTE, "$(PRE)I:4 PP")
+ field(OUTF, "$(PRE)I:5 PP")
+ field(OUTG, "$(PRE)I:6 PP")
+ field(OUTH, "$(PRE)I:7 PP")
+ field(OUTI, "$(PRE)I:8 PP")
+ field(OUTJ, "$(PRE)I:9 PP")
+ field(OUTK, "$(PRE)I:10 PP")
+ field(OUTL, "$(PRE)I:11 PP")
+ field(OUTM, "$(PRE)I:12 PP")
+ field(OUTN, "$(PRE)I:13 PP")
+ field(OUTO, "$(PRE)I:14 PP")
+ field(OUTP, "$(PRE)I:15 PP")
+ field(OUTQ, "$(PRE)I:16 PP")
+ field(OUTR, "$(PRE)I:17 PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(FTVQ, "LONG")
+ field(FTVR, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "$(PRE)Read2")
+}
+record(aSub, "$(PRE)Read2")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "$(PRE)Scalerarray")
+ field(FTA, "LONG")
+ field(NOA, "91")
+ field(INPC, "18")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "18")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "$(PRE)I:18 PP")
+ field(OUTB, "$(PRE)I:19 PP")
+ field(OUTC, "$(PRE)I:20 PP")
+ field(OUTD, "$(PRE)I:21 PP")
+ field(OUTE, "$(PRE)I:22 PP")
+ field(OUTF, "$(PRE)I:23 PP")
+ field(OUTG, "$(PRE)I:24 PP")
+ field(OUTH, "$(PRE)I:25 PP")
+ field(OUTI, "$(PRE)I:26 PP")
+ field(OUTJ, "$(PRE)I:27 PP")
+ field(OUTK, "$(PRE)I:28 PP")
+ field(OUTL, "$(PRE)I:29 PP")
+ field(OUTM, "$(PRE)I:30 PP")
+ field(OUTN, "$(PRE)I:31 PP")
+ field(OUTO, "$(PRE)I:32 PP")
+ field(OUTP, "$(PRE)I:33 PP")
+ field(OUTQ, "$(PRE)I:34 PP")
+ field(OUTR, "$(PRE)I:35 PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(FTVQ, "LONG")
+ field(FTVR, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "$(PRE)Read3")
+}
+record(aSub, "$(PRE)Read3")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "$(PRE)Scalerarray")
+ field(FTA, "LONG")
+ field(NOA, "91")
+ field(INPC, "36")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "19")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "$(PRE)D:0 PP")
+ field(OUTB, "$(PRE)D:1 PP")
+ field(OUTC, "$(PRE)D:2 PP")
+ field(OUTD, "$(PRE)D:3 PP")
+ field(OUTE, "$(PRE)D:4 PP")
+ field(OUTF, "$(PRE)D:5 PP")
+ field(OUTG, "$(PRE)D:6 PP")
+ field(OUTH, "$(PRE)D:7 PP")
+ field(OUTI, "$(PRE)D:8 PP")
+ field(OUTJ, "$(PRE)D:9 PP")
+ field(OUTK, "$(PRE)D:10 PP")
+ field(OUTL, "$(PRE)D:11 PP")
+ field(OUTM, "$(PRE)D:12 PP")
+ field(OUTN, "$(PRE)D:13 PP")
+ field(OUTO, "$(PRE)D:14 PP")
+ field(OUTP, "$(PRE)D:15 PP")
+ field(OUTQ, "$(PRE)D:16 PP")
+ field(OUTR, "$(PRE)D:17 PP")
+ field(OUTS, "$(PRE)D:18 PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(FTVQ, "LONG")
+ field(FTVR, "LONG")
+ field(FTVS, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "$(PRE)Read4")
+}
+record(aSub, "$(PRE)Read4")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "$(PRE)Scalerarray")
+ field(FTA, "LONG")
+ field(NOA, "91")
+ field(INPC, "55")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "19")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "$(PRE)A:0 PP")
+ field(OUTB, "$(PRE)A:1 PP")
+ field(OUTC, "$(PRE)A:2 PP")
+ field(OUTD, "$(PRE)A:3 PP")
+ field(OUTE, "$(PRE)A:4 PP")
+ field(OUTF, "$(PRE)A:5 PP")
+ field(OUTG, "$(PRE)A:6 PP")
+ field(OUTH, "$(PRE)A:7 PP")
+ field(OUTI, "$(PRE)A:8 PP")
+ field(OUTJ, "$(PRE)A:9 PP")
+ field(OUTK, "$(PRE)A:10 PP")
+ field(OUTL, "$(PRE)A:11 PP")
+ field(OUTM, "$(PRE)A:12 PP")
+ field(OUTN, "$(PRE)A:13 PP")
+ field(OUTO, "$(PRE)A:14 PP")
+ field(OUTP, "$(PRE)A:15 PP")
+ field(OUTQ, "$(PRE)A:16 PP")
+ field(OUTR, "$(PRE)A:17 PP")
+ field(OUTS, "$(PRE)A:18 PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(FTVQ, "LONG")
+ field(FTVR, "LONG")
+ field(FTVS, "LONG")
+ field(NOVA, "1")
+ field(FLNK, "$(PRE)Read5")
+}
+record(aSub, "$(PRE)Read5")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"scalerN_init")
+ field(SNAM,"scalerN_copy")
+ field(INPA, "$(PRE)Scalerarray")
+ field(FTA, "LONG")
+ field(NOA, "91")
+ field(INPC, "74")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "17")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "$(PRE)B:0 PP")
+ field(OUTB, "$(PRE)B:1 PP")
+ field(OUTC, "$(PRE)B:2 PP")
+ field(OUTD, "$(PRE)B:3 PP")
+ field(OUTE, "$(PRE)B:4 PP")
+ field(OUTF, "$(PRE)B:5 PP")
+ field(OUTG, "$(PRE)B:6 PP")
+ field(OUTH, "$(PRE)B:7 PP")
+ field(OUTI, "$(PRE)B:8 PP")
+ field(OUTJ, "$(PRE)B:9 PP")
+ field(OUTK, "$(PRE)B:10 PP")
+ field(OUTL, "$(PRE)B:11 PP")
+ field(OUTM, "$(PRE)B:12 PP")
+ field(OUTN, "$(PRE)B:13 PP")
+ field(OUTO, "$(PRE)B:14 PP")
+ field(OUTP, "$(PRE)B:15 PP")
+ field(OUTQ, "$(PRE)B:16 PP")
+ field(FTVA, "LONG")
+ field(FTVB, "LONG")
+ field(FTVC, "LONG")
+ field(FTVD, "LONG")
+ field(FTVE, "LONG")
+ field(FTVF, "LONG")
+ field(FTVG, "LONG")
+ field(FTVH, "LONG")
+ field(FTVI, "LONG")
+ field(FTVJ, "LONG")
+ field(FTVK, "LONG")
+ field(FTVL, "LONG")
+ field(FTVM, "LONG")
+ field(FTVN, "LONG")
+ field(FTVO, "LONG")
+ field(FTVP, "LONG")
+ field(FTVQ, "LONG")
+ field(NOVA, "1")
+}
--- /dev/null
+record(longout, "HAD:CTS:SCAL:$(NN)")
+{
+ field(DESC, "Read cts scaler $(AA) $(RR)")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:CTS:SCAL:$(NN):BUF")
+}
+record(compress,"HAD:CTS:SCAL:$(NN):BUF")
+{
+ field(DESC, "Circular buffer")
+ field(INP,"HAD:CTS:SCAL:$(NN).VAL")
+ field(ALG,"Circular Buffer")
+ field(NSAM,"60")
+ field(EGU,"Counts")
+ field(FLNK, "HAD:CTS:SCAL:$(NN):RSUM")
+}
+record(calc, "HAD:CTS:SCAL:$(NN):RSUM")
+{
+ field(DESC, "running sum")
+ field(INPA,"HAD:CTS:SCAL:$(NN).VAL NPP")
+ field(INPB,"HAD:CTS:SCAL:$(NN):RSUM.VAL NPP")
+ field(CALC,"A+B")
+ field(EGU,"Counts")
+ field(FLNK, "HAD:CTS:SCAL:$(NN):CALCOFF")
+}
+record(calcout, "HAD:CTS:SCAL:$(NN):CALCOFF")
+{
+ field(DESC, "move out of RSUM in SUM")
+ field(INPA, "HAD:CTS:BEAM:TriggerOff")
+ field(CALC, "A")
+ field(OOPT, "Transition To Non-zero")
+ field(OUT, "HAD:CTS:SCAL:$(NN):CALCMOV.PROC")
+ field(FLNK, "HAD:CTS:SCAL:$(NN):SUMCLEAR")
+}
+record(dfanout, "HAD:CTS:SCAL:$(NN):CALCMOV")
+{
+ field(DESC, "move")
+ field(DOL, "HAD:CTS:SCAL:$(NN):RSUM.VAL")
+ field(OMSL, "closed_loop")
+ field(OUTA, "HAD:CTS:SCAL:$(NN):SUM.VAL PP")
+}
+record(calcout, "HAD:CTS:SCAL:$(NN):SUMCLEAR")
+{
+ field(DESC, "move out of RSUM in SUM")
+ field(INPA, "HAD:CTS:BEAM:Trigger")
+ field(CALC, "A=1?0:1")
+ field(OOPT, "Transition To Zero")
+ field(OUT, "HAD:CTS:SCAL:$(NN):RSUM.VAL")
+}
+record(longout, "HAD:CTS:SCAL:$(NN):SUM")
+{
+ field(DESC, "Read cts scaler $(AA) $(RR)")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
--- /dev/null
+record(ai, "$(user):aiExample")
+{
+ field(DESC, "Analog input")
+ field(INP, "$(user):calcExample.VAL NPP NMS")
+ field(EGUF, "10")
+ field(EGU, "Counts")
+ field(HOPR, "10")
+ field(LOPR, "0")
+ field(HIHI, "8")
+ field(HIGH, "6")
+ field(LOW, "4")
+ field(LOLO, "2")
+ field(HHSV, "MAJOR")
+ field(HSV, "MINOR")
+ field(LSV, "MINOR")
+ field(LLSV, "MAJOR")
+}
+record(calc, "$(user):calcExample")
+{
+ field(DESC, "Counter")
+ field(SCAN,"1 second")
+ field(FLNK, "$(user):aiExample")
+ field(CALC, "(A<B)?(A+C):D")
+ field(INPA, "$(user):calcExample.VAL NPP NMS")
+ field(INPB, "9")
+ field(INPC, "1")
+ field(INPD, "0")
+ field(EGU, "Counts")
+ field(HOPR, "10")
+ field(HIHI, "8")
+ field(HIGH, "6")
+ field(LOW, "4")
+ field(LOLO, "2")
+ field(HHSV, "MAJOR")
+ field(HSV, "MINOR")
+ field(LSV, "MINOR")
+ field(LLSV, "MAJOR")
+}
+record(compress,"$(user):compressExample")
+{
+ field(DESC, "Circular buffer")
+ field(INP,"$(user):aiExample.VAL CP NMS")
+ field(ALG,"Circular Buffer")
+ field(NSAM,"10")
+ field(HOPR,"10")
+ field(EGU,"Counts")
+}
+
--- /dev/null
+record(calc, "$(user):calcExample$(no)")
+{
+ alias("$(user):calc$(no)")
+ field(DESC, "Counter No. $(no)")
+ field(SCAN,"$(scan)")
+ field(FLNK, "$(user):aiExample$(no)")
+ field(CALC, "(A<B)?(A+C):D")
+ field(INPA, "$(user):calcExample$(no).VAL NPP NMS")
+ field(INPB, "9")
+ field(INPC, "1")
+ field(INPD, "0")
+ field(EGU, "Counts")
+ field(HOPR, "10")
+ field(HIHI, "8")
+ field(HIGH, "6")
+ field(LOW, "4")
+ field(LOLO, "2")
+ field(HHSV, "MAJOR")
+ field(HSV, "MINOR")
+ field(LSV, "MINOR")
+ field(LLSV, "MAJOR")
+}
+record(ai, "$(user):aiExample$(no)")
+{
+ field(DESC, "Analog input No. $(no)")
+ field(INP, "$(user):calcExample$(no).VAL NPP NMS")
+ field(EGUF, "10")
+ field(EGU, "Counts")
+ field(HOPR, "10")
+ field(LOPR, "0")
+ field(HIHI, "8")
+ field(HIGH, "6")
+ field(LOW, "4")
+ field(LOLO, "2")
+ field(HHSV, "MAJOR")
+ field(HSV, "MINOR")
+ field(LSV, "MINOR")
+ field(LLSV, "MAJOR")
+}
+alias("$(user):aiExample$(no)","$(user):ai$(no)")
--- /dev/null
+record(sub,"$(user):subExample")
+{
+ field(INAM,"mySubInit")
+ field(SNAM,"mySubProcess")
+}
+record(aSub,"$(user):aSubExample")
+{
+ field(INAM,"myAsubInit")
+ field(SNAM,"myAsubProcess")
+ field(FTA,"DOUBLE")
+ field(NOA,"10")
+ field(INPA,"$(user):compressExample CPP")
+}
--- /dev/null
+record(sub, "HAD:MDC:OEP:Read:V0")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8010")
+ field(INPB, "0")
+}
+record(sub, "HAD:MDC:OEP:Read:V1")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8011")
+ field(INPB, "1")
+}
+record(sub, "HAD:MDC:OEP:Read:V2")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8012")
+ field(INPB, "2")
+}
+record(sub, "HAD:MDC:OEP:Read:V3")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8013")
+ field(INPB, "3")
+}
+record(sub, "HAD:MDC:OEP:Read:V4")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8014")
+ field(INPB, "4")
+}
+record(sub, "HAD:MDC:OEP:Read:V5")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8015")
+ field(INPB, "5")
+}
+record(sub, "HAD:MDC:OEP:Read:V6")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8016")
+ field(INPB, "6")
+}
+record(sub, "HAD:MDC:OEP:Read:V7")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepReadVoltage")
+ field(INPA, "0x8017")
+ field(INPB, "7")
+}
--- /dev/null
+file oepVolt.template {
+# Plane 1 Sector 1
+{P=0, PP=1, S=0, SS=1, M=0, MM=1}
+{P=0, PP=1, S=0, SS=1, M=1, MM=2}
+{P=0, PP=1, S=0, SS=1, M=2, MM=3}
+{P=0, PP=1, S=0, SS=1, M=3, MM=4}
+{P=0, PP=1, S=0, SS=1, M=4, MM=5}
+{P=0, PP=1, S=0, SS=1, M=5, MM=6}
+{P=0, PP=1, S=0, SS=1, M=6, MM=7}
+{P=0, PP=1, S=0, SS=1, M=7, MM=8}
+{P=0, PP=1, S=0, SS=1, M=8, MM=9}
+{P=0, PP=1, S=0, SS=1, M=9, MM=10}
+{P=0, PP=1, S=0, SS=1, M=10, MM=11}
+{P=0, PP=1, S=0, SS=1, M=11, MM=12}
+{P=0, PP=1, S=0, SS=1, M=12, MM=13}
+{P=0, PP=1, S=0, SS=1, M=13, MM=14}
+{P=0, PP=1, S=0, SS=1, M=14, MM=15}
+{P=0, PP=1, S=0, SS=1, M=15, MM=16}
+# Plane 1 Sector 2
+{P=0, PP=1, S=1, SS=2, M=0, MM=1}
+{P=0, PP=1, S=1, SS=2, M=1, MM=2}
+{P=0, PP=1, S=1, SS=2, M=2, MM=3}
+{P=0, PP=1, S=1, SS=2, M=3, MM=4}
+{P=0, PP=1, S=1, SS=2, M=4, MM=5}
+{P=0, PP=1, S=1, SS=2, M=5, MM=6}
+{P=0, PP=1, S=1, SS=2, M=6, MM=7}
+{P=0, PP=1, S=1, SS=2, M=7, MM=8}
+{P=0, PP=1, S=1, SS=2, M=8, MM=9}
+{P=0, PP=1, S=1, SS=2, M=9, MM=10}
+{P=0, PP=1, S=1, SS=2, M=10, MM=11}
+{P=0, PP=1, S=1, SS=2, M=11, MM=12}
+{P=0, PP=1, S=1, SS=2, M=12, MM=13}
+{P=0, PP=1, S=1, SS=2, M=13, MM=14}
+{P=0, PP=1, S=1, SS=2, M=14, MM=15}
+{P=0, PP=1, S=1, SS=2, M=15, MM=16}
+# Plane 1 Sector 3
+{P=0, PP=1, S=2, SS=3, M=0, MM=1}
+{P=0, PP=1, S=2, SS=3, M=1, MM=2}
+{P=0, PP=1, S=2, SS=3, M=2, MM=3}
+{P=0, PP=1, S=2, SS=3, M=3, MM=4}
+{P=0, PP=1, S=2, SS=3, M=4, MM=5}
+{P=0, PP=1, S=2, SS=3, M=5, MM=6}
+{P=0, PP=1, S=2, SS=3, M=6, MM=7}
+{P=0, PP=1, S=2, SS=3, M=7, MM=8}
+{P=0, PP=1, S=2, SS=3, M=8, MM=9}
+{P=0, PP=1, S=2, SS=3, M=9, MM=10}
+{P=0, PP=1, S=2, SS=3, M=10, MM=11}
+{P=0, PP=1, S=2, SS=3, M=11, MM=12}
+{P=0, PP=1, S=2, SS=3, M=12, MM=13}
+{P=0, PP=1, S=2, SS=3, M=13, MM=14}
+{P=0, PP=1, S=2, SS=3, M=14, MM=15}
+{P=0, PP=1, S=2, SS=3, M=15, MM=16}
+# Plane 1 Sector 4
+{P=0, PP=1, S=3, SS=4, M=0, MM=1}
+{P=0, PP=1, S=3, SS=4, M=1, MM=2}
+{P=0, PP=1, S=3, SS=4, M=2, MM=3}
+{P=0, PP=1, S=3, SS=4, M=3, MM=4}
+{P=0, PP=1, S=3, SS=4, M=4, MM=5}
+{P=0, PP=1, S=3, SS=4, M=5, MM=6}
+{P=0, PP=1, S=3, SS=4, M=6, MM=7}
+{P=0, PP=1, S=3, SS=4, M=7, MM=8}
+{P=0, PP=1, S=3, SS=4, M=8, MM=9}
+{P=0, PP=1, S=3, SS=4, M=9, MM=10}
+{P=0, PP=1, S=3, SS=4, M=10, MM=11}
+{P=0, PP=1, S=3, SS=4, M=11, MM=12}
+{P=0, PP=1, S=3, SS=4, M=12, MM=13}
+{P=0, PP=1, S=3, SS=4, M=13, MM=14}
+{P=0, PP=1, S=3, SS=4, M=14, MM=15}
+{P=0, PP=1, S=3, SS=4, M=15, MM=16}
+# Plane 1 Sector 5
+{P=0, PP=1, S=4, SS=5, M=0, MM=1}
+{P=0, PP=1, S=4, SS=5, M=1, MM=2}
+{P=0, PP=1, S=4, SS=5, M=2, MM=3}
+{P=0, PP=1, S=4, SS=5, M=3, MM=4}
+{P=0, PP=1, S=4, SS=5, M=4, MM=5}
+{P=0, PP=1, S=4, SS=5, M=5, MM=6}
+{P=0, PP=1, S=4, SS=5, M=6, MM=7}
+{P=0, PP=1, S=4, SS=5, M=7, MM=8}
+{P=0, PP=1, S=4, SS=5, M=8, MM=9}
+{P=0, PP=1, S=4, SS=5, M=9, MM=10}
+{P=0, PP=1, S=4, SS=5, M=10, MM=11}
+{P=0, PP=1, S=4, SS=5, M=11, MM=12}
+{P=0, PP=1, S=4, SS=5, M=12, MM=13}
+{P=0, PP=1, S=4, SS=5, M=13, MM=14}
+{P=0, PP=1, S=4, SS=5, M=14, MM=15}
+{P=0, PP=1, S=4, SS=5, M=15, MM=16}
+# Plane 1 Sector 6
+{P=0, PP=1, S=5, SS=6, M=0, MM=1}
+{P=0, PP=1, S=5, SS=6, M=1, MM=2}
+{P=0, PP=1, S=5, SS=6, M=2, MM=3}
+{P=0, PP=1, S=5, SS=6, M=3, MM=4}
+{P=0, PP=1, S=5, SS=6, M=4, MM=5}
+{P=0, PP=1, S=5, SS=6, M=5, MM=6}
+{P=0, PP=1, S=5, SS=6, M=6, MM=7}
+{P=0, PP=1, S=5, SS=6, M=7, MM=8}
+{P=0, PP=1, S=5, SS=6, M=8, MM=9}
+{P=0, PP=1, S=5, SS=6, M=9, MM=10}
+{P=0, PP=1, S=5, SS=6, M=10, MM=11}
+{P=0, PP=1, S=5, SS=6, M=11, MM=12}
+{P=0, PP=1, S=5, SS=6, M=12, MM=13}
+{P=0, PP=1, S=5, SS=6, M=13, MM=14}
+{P=0, PP=1, S=5, SS=6, M=14, MM=15}
+{P=0, PP=1, S=5, SS=6, M=15, MM=16}
+# Plane 2 Sector 1
+{P=1, PP=2, S=0, SS=1, M=0, MM=1}
+{P=1, PP=2, S=0, SS=1, M=1, MM=2}
+{P=1, PP=2, S=0, SS=1, M=2, MM=3}
+{P=1, PP=2, S=0, SS=1, M=3, MM=4}
+{P=1, PP=2, S=0, SS=1, M=4, MM=5}
+{P=1, PP=2, S=0, SS=1, M=5, MM=6}
+{P=1, PP=2, S=0, SS=1, M=6, MM=7}
+{P=1, PP=2, S=0, SS=1, M=7, MM=8}
+{P=1, PP=2, S=0, SS=1, M=8, MM=9}
+{P=1, PP=2, S=0, SS=1, M=9, MM=10}
+{P=1, PP=2, S=0, SS=1, M=10, MM=11}
+{P=1, PP=2, S=0, SS=1, M=11, MM=12}
+{P=1, PP=2, S=0, SS=1, M=12, MM=13}
+{P=1, PP=2, S=0, SS=1, M=13, MM=14}
+{P=1, PP=2, S=0, SS=1, M=14, MM=15}
+{P=1, PP=2, S=0, SS=1, M=15, MM=16}
+# Plane 2 Sector 2
+{P=1, PP=2, S=1, SS=2, M=0, MM=1}
+{P=1, PP=2, S=1, SS=2, M=1, MM=2}
+{P=1, PP=2, S=1, SS=2, M=2, MM=3}
+{P=1, PP=2, S=1, SS=2, M=3, MM=4}
+{P=1, PP=2, S=1, SS=2, M=4, MM=5}
+{P=1, PP=2, S=1, SS=2, M=5, MM=6}
+{P=1, PP=2, S=1, SS=2, M=6, MM=7}
+{P=1, PP=2, S=1, SS=2, M=7, MM=8}
+{P=1, PP=2, S=1, SS=2, M=8, MM=9}
+{P=1, PP=2, S=1, SS=2, M=9, MM=10}
+{P=1, PP=2, S=1, SS=2, M=10, MM=11}
+{P=1, PP=2, S=1, SS=2, M=11, MM=12}
+{P=1, PP=2, S=1, SS=2, M=12, MM=13}
+{P=1, PP=2, S=1, SS=2, M=13, MM=14}
+{P=1, PP=2, S=1, SS=2, M=14, MM=15}
+{P=1, PP=2, S=1, SS=2, M=15, MM=16}
+# Plane 2 Sector 3
+{P=1, PP=2, S=2, SS=3, M=0, MM=1}
+{P=1, PP=2, S=2, SS=3, M=1, MM=2}
+{P=1, PP=2, S=2, SS=3, M=2, MM=3}
+{P=1, PP=2, S=2, SS=3, M=3, MM=4}
+{P=1, PP=2, S=2, SS=3, M=4, MM=5}
+{P=1, PP=2, S=2, SS=3, M=5, MM=6}
+{P=1, PP=2, S=2, SS=3, M=6, MM=7}
+{P=1, PP=2, S=2, SS=3, M=7, MM=8}
+{P=1, PP=2, S=2, SS=3, M=8, MM=9}
+{P=1, PP=2, S=2, SS=3, M=9, MM=10}
+{P=1, PP=2, S=2, SS=3, M=10, MM=11}
+{P=1, PP=2, S=2, SS=3, M=11, MM=12}
+{P=1, PP=2, S=2, SS=3, M=12, MM=13}
+{P=1, PP=2, S=2, SS=3, M=13, MM=14}
+{P=1, PP=2, S=2, SS=3, M=14, MM=15}
+{P=1, PP=2, S=2, SS=3, M=15, MM=16}
+# Plane 2 Sector 4
+{P=1, PP=2, S=3, SS=4, M=0, MM=1}
+{P=1, PP=2, S=3, SS=4, M=1, MM=2}
+{P=1, PP=2, S=3, SS=4, M=2, MM=3}
+{P=1, PP=2, S=3, SS=4, M=3, MM=4}
+{P=1, PP=2, S=3, SS=4, M=4, MM=5}
+{P=1, PP=2, S=3, SS=4, M=5, MM=6}
+{P=1, PP=2, S=3, SS=4, M=6, MM=7}
+{P=1, PP=2, S=3, SS=4, M=7, MM=8}
+{P=1, PP=2, S=3, SS=4, M=8, MM=9}
+{P=1, PP=2, S=3, SS=4, M=9, MM=10}
+{P=1, PP=2, S=3, SS=4, M=10, MM=11}
+{P=1, PP=2, S=3, SS=4, M=11, MM=12}
+{P=1, PP=2, S=3, SS=4, M=12, MM=13}
+{P=1, PP=2, S=3, SS=4, M=13, MM=14}
+{P=1, PP=2, S=3, SS=4, M=14, MM=15}
+{P=1, PP=2, S=3, SS=4, M=15, MM=16}
+# Plane 2 Sector 5
+{P=1, PP=2, S=4, SS=5, M=0, MM=1}
+{P=1, PP=2, S=4, SS=5, M=1, MM=2}
+{P=1, PP=2, S=4, SS=5, M=2, MM=3}
+{P=1, PP=2, S=4, SS=5, M=3, MM=4}
+{P=1, PP=2, S=4, SS=5, M=4, MM=5}
+{P=1, PP=2, S=4, SS=5, M=5, MM=6}
+{P=1, PP=2, S=4, SS=5, M=6, MM=7}
+{P=1, PP=2, S=4, SS=5, M=7, MM=8}
+{P=1, PP=2, S=4, SS=5, M=8, MM=9}
+{P=1, PP=2, S=4, SS=5, M=9, MM=10}
+{P=1, PP=2, S=4, SS=5, M=10, MM=11}
+{P=1, PP=2, S=4, SS=5, M=11, MM=12}
+{P=1, PP=2, S=4, SS=5, M=12, MM=13}
+{P=1, PP=2, S=4, SS=5, M=13, MM=14}
+{P=1, PP=2, S=4, SS=5, M=14, MM=15}
+{P=1, PP=2, S=4, SS=5, M=15, MM=16}
+# Plane 2 Sector 6
+{P=1, PP=2, S=5, SS=6, M=0, MM=1}
+{P=1, PP=2, S=5, SS=6, M=1, MM=2}
+{P=1, PP=2, S=5, SS=6, M=2, MM=3}
+{P=1, PP=2, S=5, SS=6, M=3, MM=4}
+{P=1, PP=2, S=5, SS=6, M=4, MM=5}
+{P=1, PP=2, S=5, SS=6, M=5, MM=6}
+{P=1, PP=2, S=5, SS=6, M=6, MM=7}
+{P=1, PP=2, S=5, SS=6, M=7, MM=8}
+{P=1, PP=2, S=5, SS=6, M=8, MM=9}
+{P=1, PP=2, S=5, SS=6, M=9, MM=10}
+{P=1, PP=2, S=5, SS=6, M=10, MM=11}
+{P=1, PP=2, S=5, SS=6, M=11, MM=12}
+{P=1, PP=2, S=5, SS=6, M=12, MM=13}
+{P=1, PP=2, S=5, SS=6, M=13, MM=14}
+{P=1, PP=2, S=5, SS=6, M=14, MM=15}
+{P=1, PP=2, S=5, SS=6, M=15, MM=16}
+# Plane 3 Sector 1
+{P=2, PP=3, S=0, SS=1, M=0, MM=1}
+{P=2, PP=3, S=0, SS=1, M=1, MM=2}
+{P=2, PP=3, S=0, SS=1, M=2, MM=3}
+{P=2, PP=3, S=0, SS=1, M=3, MM=4}
+{P=2, PP=3, S=0, SS=1, M=4, MM=5}
+{P=2, PP=3, S=0, SS=1, M=5, MM=6}
+{P=2, PP=3, S=0, SS=1, M=6, MM=7}
+{P=2, PP=3, S=0, SS=1, M=7, MM=8}
+{P=2, PP=3, S=0, SS=1, M=8, MM=9}
+{P=2, PP=3, S=0, SS=1, M=9, MM=10}
+{P=2, PP=3, S=0, SS=1, M=10, MM=11}
+{P=2, PP=3, S=0, SS=1, M=11, MM=12}
+{P=2, PP=3, S=0, SS=1, M=12, MM=13}
+{P=2, PP=3, S=0, SS=1, M=13, MM=14}
+{P=2, PP=3, S=0, SS=1, M=14, MM=15}
+{P=2, PP=3, S=0, SS=1, M=15, MM=16}
+# Plane 3 Sector 2
+{P=2, PP=3, S=1, SS=2, M=0, MM=1}
+{P=2, PP=3, S=1, SS=2, M=1, MM=2}
+{P=2, PP=3, S=1, SS=2, M=2, MM=3}
+{P=2, PP=3, S=1, SS=2, M=3, MM=4}
+{P=2, PP=3, S=1, SS=2, M=4, MM=5}
+{P=2, PP=3, S=1, SS=2, M=5, MM=6}
+{P=2, PP=3, S=1, SS=2, M=6, MM=7}
+{P=2, PP=3, S=1, SS=2, M=7, MM=8}
+{P=2, PP=3, S=1, SS=2, M=8, MM=9}
+{P=2, PP=3, S=1, SS=2, M=9, MM=10}
+{P=2, PP=3, S=1, SS=2, M=10, MM=11}
+{P=2, PP=3, S=1, SS=2, M=11, MM=12}
+{P=2, PP=3, S=1, SS=2, M=12, MM=13}
+{P=2, PP=3, S=1, SS=2, M=13, MM=14}
+{P=2, PP=3, S=1, SS=2, M=14, MM=15}
+{P=2, PP=3, S=1, SS=2, M=15, MM=16}
+# Plane 3 Sector 3
+{P=2, PP=3, S=2, SS=3, M=0, MM=1}
+{P=2, PP=3, S=2, SS=3, M=1, MM=2}
+{P=2, PP=3, S=2, SS=3, M=2, MM=3}
+{P=2, PP=3, S=2, SS=3, M=3, MM=4}
+{P=2, PP=3, S=2, SS=3, M=4, MM=5}
+{P=2, PP=3, S=2, SS=3, M=5, MM=6}
+{P=2, PP=3, S=2, SS=3, M=6, MM=7}
+{P=2, PP=3, S=2, SS=3, M=7, MM=8}
+{P=2, PP=3, S=2, SS=3, M=8, MM=9}
+{P=2, PP=3, S=2, SS=3, M=9, MM=10}
+{P=2, PP=3, S=2, SS=3, M=10, MM=11}
+{P=2, PP=3, S=2, SS=3, M=11, MM=12}
+{P=2, PP=3, S=2, SS=3, M=12, MM=13}
+{P=2, PP=3, S=2, SS=3, M=13, MM=14}
+{P=2, PP=3, S=2, SS=3, M=14, MM=15}
+{P=2, PP=3, S=2, SS=3, M=15, MM=16}
+# Plane 3 Sector 4
+{P=2, PP=3, S=3, SS=4, M=0, MM=1}
+{P=2, PP=3, S=3, SS=4, M=1, MM=2}
+{P=2, PP=3, S=3, SS=4, M=2, MM=3}
+{P=2, PP=3, S=3, SS=4, M=3, MM=4}
+{P=2, PP=3, S=3, SS=4, M=4, MM=5}
+{P=2, PP=3, S=3, SS=4, M=5, MM=6}
+{P=2, PP=3, S=3, SS=4, M=6, MM=7}
+{P=2, PP=3, S=3, SS=4, M=7, MM=8}
+{P=2, PP=3, S=3, SS=4, M=8, MM=9}
+{P=2, PP=3, S=3, SS=4, M=9, MM=10}
+{P=2, PP=3, S=3, SS=4, M=10, MM=11}
+{P=2, PP=3, S=3, SS=4, M=11, MM=12}
+{P=2, PP=3, S=3, SS=4, M=12, MM=13}
+{P=2, PP=3, S=3, SS=4, M=13, MM=14}
+{P=2, PP=3, S=3, SS=4, M=14, MM=15}
+{P=2, PP=3, S=3, SS=4, M=15, MM=16}
+# Plane 3 Sector 5
+{P=2, PP=3, S=4, SS=5, M=0, MM=1}
+{P=2, PP=3, S=4, SS=5, M=1, MM=2}
+{P=2, PP=3, S=4, SS=5, M=2, MM=3}
+{P=2, PP=3, S=4, SS=5, M=3, MM=4}
+{P=2, PP=3, S=4, SS=5, M=4, MM=5}
+{P=2, PP=3, S=4, SS=5, M=5, MM=6}
+{P=2, PP=3, S=4, SS=5, M=6, MM=7}
+{P=2, PP=3, S=4, SS=5, M=7, MM=8}
+{P=2, PP=3, S=4, SS=5, M=8, MM=9}
+{P=2, PP=3, S=4, SS=5, M=9, MM=10}
+{P=2, PP=3, S=4, SS=5, M=10, MM=11}
+{P=2, PP=3, S=4, SS=5, M=11, MM=12}
+{P=2, PP=3, S=4, SS=5, M=12, MM=13}
+{P=2, PP=3, S=4, SS=5, M=13, MM=14}
+{P=2, PP=3, S=4, SS=5, M=14, MM=15}
+{P=2, PP=3, S=4, SS=5, M=15, MM=16}
+# Plane 3 Sector 6
+{P=2, PP=3, S=5, SS=6, M=0, MM=1}
+{P=2, PP=3, S=5, SS=6, M=1, MM=2}
+{P=2, PP=3, S=5, SS=6, M=2, MM=3}
+{P=2, PP=3, S=5, SS=6, M=3, MM=4}
+{P=2, PP=3, S=5, SS=6, M=4, MM=5}
+{P=2, PP=3, S=5, SS=6, M=5, MM=6}
+{P=2, PP=3, S=5, SS=6, M=6, MM=7}
+{P=2, PP=3, S=5, SS=6, M=7, MM=8}
+{P=2, PP=3, S=5, SS=6, M=8, MM=9}
+{P=2, PP=3, S=5, SS=6, M=9, MM=10}
+{P=2, PP=3, S=5, SS=6, M=10, MM=11}
+{P=2, PP=3, S=5, SS=6, M=11, MM=12}
+{P=2, PP=3, S=5, SS=6, M=12, MM=13}
+{P=2, PP=3, S=5, SS=6, M=13, MM=14}
+{P=2, PP=3, S=5, SS=6, M=14, MM=15}
+{P=2, PP=3, S=5, SS=6, M=15, MM=16}
+# Plane 4 Sector 1
+{P=3, PP=4, S=0, SS=1, M=0, MM=1}
+{P=3, PP=4, S=0, SS=1, M=1, MM=2}
+{P=3, PP=4, S=0, SS=1, M=2, MM=3}
+{P=3, PP=4, S=0, SS=1, M=3, MM=4}
+{P=3, PP=4, S=0, SS=1, M=4, MM=5}
+{P=3, PP=4, S=0, SS=1, M=5, MM=6}
+{P=3, PP=4, S=0, SS=1, M=6, MM=7}
+{P=3, PP=4, S=0, SS=1, M=7, MM=8}
+{P=3, PP=4, S=0, SS=1, M=8, MM=9}
+{P=3, PP=4, S=0, SS=1, M=9, MM=10}
+{P=3, PP=4, S=0, SS=1, M=10, MM=11}
+{P=3, PP=4, S=0, SS=1, M=11, MM=12}
+{P=3, PP=4, S=0, SS=1, M=12, MM=13}
+{P=3, PP=4, S=0, SS=1, M=13, MM=14}
+{P=3, PP=4, S=0, SS=1, M=14, MM=15}
+{P=3, PP=4, S=0, SS=1, M=15, MM=16}
+# Plane 4 Sector 2
+{P=3, PP=4, S=1, SS=2, M=0, MM=1}
+{P=3, PP=4, S=1, SS=2, M=1, MM=2}
+{P=3, PP=4, S=1, SS=2, M=2, MM=3}
+{P=3, PP=4, S=1, SS=2, M=3, MM=4}
+{P=3, PP=4, S=1, SS=2, M=4, MM=5}
+{P=3, PP=4, S=1, SS=2, M=5, MM=6}
+{P=3, PP=4, S=1, SS=2, M=6, MM=7}
+{P=3, PP=4, S=1, SS=2, M=7, MM=8}
+{P=3, PP=4, S=1, SS=2, M=8, MM=9}
+{P=3, PP=4, S=1, SS=2, M=9, MM=10}
+{P=3, PP=4, S=1, SS=2, M=10, MM=11}
+{P=3, PP=4, S=1, SS=2, M=11, MM=12}
+{P=3, PP=4, S=1, SS=2, M=12, MM=13}
+{P=3, PP=4, S=1, SS=2, M=13, MM=14}
+{P=3, PP=4, S=1, SS=2, M=14, MM=15}
+{P=3, PP=4, S=1, SS=2, M=15, MM=16}
+# Plane 4 Sector 3
+{P=3, PP=4, S=2, SS=3, M=0, MM=1}
+{P=3, PP=4, S=2, SS=3, M=1, MM=2}
+{P=3, PP=4, S=2, SS=3, M=2, MM=3}
+{P=3, PP=4, S=2, SS=3, M=3, MM=4}
+{P=3, PP=4, S=2, SS=3, M=4, MM=5}
+{P=3, PP=4, S=2, SS=3, M=5, MM=6}
+{P=3, PP=4, S=2, SS=3, M=6, MM=7}
+{P=3, PP=4, S=2, SS=3, M=7, MM=8}
+{P=3, PP=4, S=2, SS=3, M=8, MM=9}
+{P=3, PP=4, S=2, SS=3, M=9, MM=10}
+{P=3, PP=4, S=2, SS=3, M=10, MM=11}
+{P=3, PP=4, S=2, SS=3, M=11, MM=12}
+{P=3, PP=4, S=2, SS=3, M=12, MM=13}
+{P=3, PP=4, S=2, SS=3, M=13, MM=14}
+{P=3, PP=4, S=2, SS=3, M=14, MM=15}
+{P=3, PP=4, S=2, SS=3, M=15, MM=16}
+# Plane 4 Sector 4
+{P=3, PP=4, S=3, SS=4, M=0, MM=1}
+{P=3, PP=4, S=3, SS=4, M=1, MM=2}
+{P=3, PP=4, S=3, SS=4, M=2, MM=3}
+{P=3, PP=4, S=3, SS=4, M=3, MM=4}
+{P=3, PP=4, S=3, SS=4, M=4, MM=5}
+{P=3, PP=4, S=3, SS=4, M=5, MM=6}
+{P=3, PP=4, S=3, SS=4, M=6, MM=7}
+{P=3, PP=4, S=3, SS=4, M=7, MM=8}
+{P=3, PP=4, S=3, SS=4, M=8, MM=9}
+{P=3, PP=4, S=3, SS=4, M=9, MM=10}
+{P=3, PP=4, S=3, SS=4, M=10, MM=11}
+{P=3, PP=4, S=3, SS=4, M=11, MM=12}
+{P=3, PP=4, S=3, SS=4, M=12, MM=13}
+{P=3, PP=4, S=3, SS=4, M=13, MM=14}
+{P=3, PP=4, S=3, SS=4, M=14, MM=15}
+{P=3, PP=4, S=3, SS=4, M=15, MM=16}
+# Plane 4 Sector 5
+{P=3, PP=4, S=4, SS=5, M=0, MM=1}
+{P=3, PP=4, S=4, SS=5, M=1, MM=2}
+{P=3, PP=4, S=4, SS=5, M=2, MM=3}
+{P=3, PP=4, S=4, SS=5, M=3, MM=4}
+{P=3, PP=4, S=4, SS=5, M=4, MM=5}
+{P=3, PP=4, S=4, SS=5, M=5, MM=6}
+{P=3, PP=4, S=4, SS=5, M=6, MM=7}
+{P=3, PP=4, S=4, SS=5, M=7, MM=8}
+{P=3, PP=4, S=4, SS=5, M=8, MM=9}
+{P=3, PP=4, S=4, SS=5, M=9, MM=10}
+{P=3, PP=4, S=4, SS=5, M=10, MM=11}
+{P=3, PP=4, S=4, SS=5, M=11, MM=12}
+{P=3, PP=4, S=4, SS=5, M=12, MM=13}
+{P=3, PP=4, S=4, SS=5, M=13, MM=14}
+{P=3, PP=4, S=4, SS=5, M=14, MM=15}
+{P=3, PP=4, S=4, SS=5, M=15, MM=16}
+# Plane 4 Sector 6
+{P=3, PP=4, S=5, SS=6, M=0, MM=1}
+{P=3, PP=4, S=5, SS=6, M=1, MM=2}
+{P=3, PP=4, S=5, SS=6, M=2, MM=3}
+{P=3, PP=4, S=5, SS=6, M=3, MM=4}
+{P=3, PP=4, S=5, SS=6, M=4, MM=5}
+{P=3, PP=4, S=5, SS=6, M=5, MM=6}
+{P=3, PP=4, S=5, SS=6, M=6, MM=7}
+{P=3, PP=4, S=5, SS=6, M=7, MM=8}
+{P=3, PP=4, S=5, SS=6, M=8, MM=9}
+{P=3, PP=4, S=5, SS=6, M=9, MM=10}
+{P=3, PP=4, S=5, SS=6, M=10, MM=11}
+{P=3, PP=4, S=5, SS=6, M=11, MM=12}
+{P=3, PP=4, S=5, SS=6, M=12, MM=13}
+{P=3, PP=4, S=5, SS=6, M=13, MM=14}
+{P=3, PP=4, S=5, SS=6, M=14, MM=15}
+{P=3, PP=4, S=5, SS=6, M=15, MM=16}
+
+}
\ No newline at end of file
--- /dev/null
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V0")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "0")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V1")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "1")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V2")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "2")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V3")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "3")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V4")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "4")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V5")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "5")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V6")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "6")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
+record(sub, "HAD:MDC:OEP:P$(PP):S$(SS):M$(MM):V7")
+{
+ field(DESC, "Read OEP Voltages")
+ field(SCAN,"1 second")
+ field(INAM,"oepInit")
+ field(SNAM,"oepGetVoltage")
+ field(INPA, "7")
+ field(INPB, "$(S)")
+ field(INPC, "$(P)")
+ field(INPD, "$(M)")
+ field(PREC, "3")
+}
--- /dev/null
+record(aSub, "HAD:TRB:trbUid")
+{
+ field(DESC, "Read trbnet UID")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbUid")
+ field(INPA, "HAD:TRB:ADDR NPP NMS")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(OUTA, "HAD:TRB:UIDA")
+ field(FTVA, "LONG")
+ field(NOVA, "1")
+ field(OUTB, "HAD:TRB:UIDB")
+ field(FTVB, "LONG")
+ field(NOVB, "1")
+ field(OUTC, "HAD:TRB:UIDC")
+ field(FTVC, "LONG")
+ field(NOVC, "1")
+ field(FLNK, "HAD:TRB:UIDA")
+}
+record(longout, "HAD:TRB:ADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:UIDA")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:TRB:UIDB")
+}
+record(longout, "HAD:TRB:UIDB")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+ field(FLNK, "HAD:TRB:UIDC")
+}
+record(longout, "HAD:TRB:UIDC")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+# read register
+record(aSub, "HAD:TRB:trbRead")
+{
+ field(DESC, "Read trbnet Register")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbRead")
+ field(INPA, "HAD:TRB:READ:TRBADDR NPP NMS")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:TRB:READ:REGADDR NPP NMS")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:TRB:READ:REGCOUNT NPP NMS")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(OUTA, "HAD:TRB:READ:REGVAL")
+ field(FTVA, "LONG")
+ field(NOVA, "2048")
+ field(OUTB, "HAD:TRB:READ:REGVALB")
+ field(FTVB, "LONG")
+ field(NOVB, "2048")
+ field(FLNK, "HAD:TRB:READ:REGVAL")
+}
+record(longout, "HAD:TRB:READ:TRBADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:READ:REGADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:READ:REGCOUNT")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "1")
+}
+#record(longout, "HAD:TRB:READ:REGVAL")
+#{
+# field(DESC, "Addr")
+# field(SCAN,"Passive")
+# field(OUT, "0")
+#}
+record(waveform, "HAD:TRB:READ:REGVAL")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "2048")
+ field(FTVL, "LONG")
+ field(FLNK, "HAD:TRB:READ:REGVALB")
+}
+record(waveform, "HAD:TRB:READ:REGVALB")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "2048")
+ field(FTVL, "LONG")
+}
+# write register
+record(aSub, "HAD:TRB:trbWrite")
+{
+ field(DESC, "Read trbnet UID")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbWrite")
+ field(INPA, "HAD:TRB:WRITE:TRBADDR NPP NMS")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:TRB:WRITE:REGADDR NPP NMS")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:TRB:WRITE:REGVAL")
+ field(FTC, "LONG")
+ field(NOC, "1")
+}
+record(longout, "HAD:TRB:WRITE:TRBADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:WRITE:REGADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:WRITE:REGVAL")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+# read register
+record(aSub, "HAD:TRB:trbReadM")
+{
+ field(DESC, "Read trbnet Register multiple")
+ field(SCAN,"Passive")
+ field(INAM,"mytrbInit")
+ field(SNAM,"mytrbReadMem")
+ field(INPA, "HAD:TRB:READM:TRBADDR NPP NMS")
+ field(FTA, "LONG")
+ field(NOA, "1")
+ field(INPB, "HAD:TRB:READM:REGADDR NPP NMS")
+ field(FTB, "LONG")
+ field(NOB, "1")
+ field(INPC, "HAD:TRB:READM:REGCOUNT NPP NMS")
+ field(FTC, "LONG")
+ field(NOC, "1")
+ field(INPD, "HAD:TRB:READM:OPTION NPP NMS")
+ field(FTD, "LONG")
+ field(NOD, "1")
+ field(OUTA, "HAD:TRB:READM:REGVAL")
+ field(FTVA, "LONG")
+ field(NOVA, "2048")
+ field(FLNK, "HAD:TRB:READM:REGVAL")
+}
+record(longout, "HAD:TRB:READM:TRBADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:READM:REGADDR")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "0")
+}
+record(longout, "HAD:TRB:READM:REGCOUNT")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "1")
+}
+record(longout, "HAD:TRB:READM:OPTION")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(OUT, "1")
+}
+record(waveform, "HAD:TRB:READM:REGVAL")
+{
+ field(DESC, "Addr")
+ field(SCAN,"Passive")
+ field(INP, "0")
+ field(NELM, "2048")
+ field(FTVL, "LONG")
+}
--- /dev/null
+# Example substitutions file
+
+file "db/dbExample1.db" {
+ { user = "scs" }
+}
+
+file db/dbExample2.db {
+ pattern { user, no, scan }
+ { "scs", 1, "1 second" }
+ { "scs", 2, "2 second" }
+ { "scs", 3, "5 second" }
+}
--- /dev/null
+# Example substitutions file
+
+file "db/dbExample1.db" {
+ { user = "scsHost" }
+}
+
+file db/dbExample2.db {
+ pattern { user, no, scan }
+ { "scsHost", 1, "1 second" }
+ { "scsHost", 2, "2 second" }
+ { "scsHost", 3, "5 second" }
+}
--- /dev/null
+TOP = ..
+include $(TOP)/configure/CONFIG
+DIRS := $(DIRS) $(filter-out $(DIRS), $(wildcard *src*))
+DIRS := $(DIRS) $(filter-out $(DIRS), $(wildcard *Src*))
+DIRS := $(DIRS) $(filter-out $(DIRS), $(wildcard *db*))
+DIRS := $(DIRS) $(filter-out $(DIRS), $(wildcard *Db*))
+include $(TOP)/configure/RULES_DIRS
+
--- /dev/null
+TOP=../..
+
+include $(TOP)/configure/CONFIG
+#----------------------------------------
+# ADD MACRO DEFINITIONS AFTER THIS LINE
+
+#=============================
+# Build the IOC support library
+
+LIBRARY_IOC += trbSupport
+
+# xxxRecord.h will be created from xxxRecord.dbd
+#DBDINC += xxxRecord
+# Install devXxxSoft.dbd into <top>/dbd
+#DBD += xxxSupport.dbd
+
+# Compile and add the code to the support libraryls i
+#trbSupport_SRCS += xxxRecord.c
+#trbSupport_SRCS += devXxxSoft.c
+
+# Link locally-provided code into the support library,
+# rather than directly into the IOC application.
+trbSupport_SRCS += trbSub.c
+trbSupport_SRCS += trbHello.c
+trbSupport_SRCS += initTrace.c
+
+trbSupport_LIBS += $(EPICS_BASE_IOC_LIBS)
+
+#=============================
+# Build the IOC application
+
+PROD_IOC = trb
+# trb.dbd will be created and installed
+DBD += trb.dbd
+
+
+# trb.dbd will be made up from these files:
+trb_DBD += base.dbd
+trb_DBD += trbSub.dbd
+trb_DBD += trbHello.dbd
+trb_DBD += initTrace.dbd
+
+
+# trb_registerRecordDeviceDriver.cpp derives from trb.dbd
+trb_SRCS += trb_registerRecordDeviceDriver.cpp
+
+# Build the main IOC entry point on workstation OSs.
+trb_SRCS_DEFAULT += trbMain.cpp
+trb_SRCS_vxWorks += -nil-
+
+# Add support from base/src/vxWorks if needed
+#trb_OBJS_vxWorks += $(EPICS_BASE_BIN)/vxComLibrary
+
+# headers
+LIB_INSTALLS += ../extern/trbnet/lib/$(T_A)/libtrbnet.a
+
+# includes
+USR_INCLUDES += -I../extern/trbnet/include
+
+# Link in the code from the support library
+trb_DIR += ../extern/$(T_A)
+trb_LIBS += trbSupport trbnet
+
+# NOTE: To build SNL programs, SNCSEQ must be defined
+# in the <top>/configure/RELEASE file
+
+ifneq ($(SNCSEQ),)
+ # Build sncExample into trbSupport
+ sncExample_SNCFLAGS += +r
+ trb_DBD += sncExample.dbd
+ trbSupport_SRCS += sncExample.stt
+ trbSupport_LIBS += seq pv
+ trb_LIBS += seq pv
+
+ # Build sncProgram as a standalone program
+ PROD_HOST += sncProgram
+ sncProgram_SNCFLAGS += +m
+ sncProgram_SRCS += sncProgram.st
+ sncProgram_LIBS += seq pv
+ sncProgram_LIBS += $(EPICS_BASE_HOST_LIBS)
+endif
+
+# Finally link to the EPICS Base libraries
+trb_LIBS += $(EPICS_BASE_IOC_LIBS)
+
+#=============================
+
+include $(TOP)/configure/RULES
+#----------------------------------------
+# ADD RULES AFTER THIS LINE
+
--- /dev/null
+#include <stdio.h>
+
+#include <dbDefs.h>
+#include <registryFunction.h>
+#include <subRecord.h>
+#include <aSubRecord.h>
+#include <epicsExport.h>
+
+int mySubDebug;
+
+static long mySubInit(subRecord *precord)
+{
+ if (mySubDebug)
+ printf("Record %s called mySubInit(%p)\n",
+ precord->name, (void*) precord);
+ return 0;
+}
+
+static long mySubProcess(subRecord *precord)
+{
+ if (mySubDebug)
+ printf("Record %s called mySubProcess(%p)\n",
+ precord->name, (void*) precord);
+ return 0;
+}
+
+static long myAsubInit(aSubRecord *precord)
+{
+ if (mySubDebug)
+ printf("Record %s called myAsubInit(%p)\n",
+ precord->name, (void*) precord);
+ return 0;
+}
+
+static long myAsubProcess(aSubRecord *precord)
+{
+ if (mySubDebug)
+ printf("Record %s called myAsubProcess(%p)\n",
+ precord->name, (void*) precord);
+ return 0;
+}
+
+/* Register these symbols for use by IOC code: */
+
+epicsExportAddress(int, mySubDebug);
+epicsRegisterFunction(mySubInit);
+epicsRegisterFunction(mySubProcess);
+epicsRegisterFunction(myAsubInit);
+epicsRegisterFunction(myAsubProcess);
--- /dev/null
+variable(mySubDebug)
+function(mySubInit)
+function(mySubProcess)
+function(myAsubInit)
+function(myAsubProcess)
--- /dev/null
+#ifndef TRBERROR_H
+#define TRBERROR_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+ TRB_NONE = 0,
+ TRB_TX_BUSY = 1,
+ TRB_FIFO_NOT_EMPTY = 2,
+ TRB_FIFO_TIMEOUT = 3,
+ TRB_FIFO_HEADERS = 4,
+ TRB_FIFO_SEQUENZ = 5,
+ TRB_FIFO_INVALID_MODE = 6,
+ TRB_FIFO_INCOMPLETE_PACKAGE = 7,
+ TRB_FIFO_INVALID_HEADER = 8,
+ TRB_FIFO_MISSING_TERM_HEADER = 9,
+ TRB_FAILED_WAIT_IS_VALID = 10,
+ TRB_FAILED_WAIT_IS_NOT_VALID = 11,
+ TRB_USER_BUFFER_OVF = 12,
+ TRB_INVALID_CHANNEL = 13,
+ TRB_INVALID_PKG_NUMBER = 14,
+ TRB_STATUS_ERROR = 15,
+ TRB_INVALID_ADDRESS = 16,
+ TRB_INVALID_LENGTH = 17,
+ TRB_ENDPOINT_NOT_REACHED = 18,
+ TRB_DMA_UNAVAILABLE = 19,
+ TRB_DMA_TIMEOUT = 20,
+ TRB_READMEM_INVALID_SIZE = 21,
+ TRB_HDR_DLEN = 22,
+ TRB_FIFO_INCOMPLETE = 23,
+ TRB_SEMAPHORE = 24,
+ TRB_FIFO_SHARED_MEM = 25,
+ TRB_STATUS_WARNING = 26,
+ TRB_RPC_ERROR = 27
+} TRB_ERROR;
+
+/* last TRBNet-TermPackage */
+typedef struct {
+ uint16_t status_common;
+ uint16_t status_channel;
+ uint16_t sequence;
+ uint8_t channel;
+} TRB_TERM;
+
+extern int trb_errno;
+
+extern TRB_TERM trb_term;
+
+void trb_error(const char *s);
+
+const char* trb_strerror();
+
+
+const char* trb_errorstr(int trberrno);
+
+const char* trb_termstr(TRB_TERM term);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef TRBNET_H
+#define TRBNET_H
+
+extern const char trbnet_version[];
+
+#include <stdint.h>
+#include <stdio.h>
+
+extern unsigned int trb_debug;
+extern unsigned int trb_dma;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ---------------------------------------------------------------------- */
+
+int trb_connect(const char* server);
+
+int init_ports();
+
+int trb_register_read(uint16_t trb_address,
+ uint16_t reg_address,
+ uint32_t* data,
+ unsigned int dsize);
+
+int trb_registertime_read(uint16_t trb_address,
+ uint16_t reg_address,
+ uint32_t* data,
+ unsigned int dsize);
+
+int trb_register_read_mem(uint16_t trb_address,
+ uint16_t reg_address,
+ uint8_t option,
+ uint16_t size,
+ uint32_t* data,
+ unsigned int dsize);
+
+int trb_registertime_read_mem(uint16_t trb_address,
+ uint16_t reg_address,
+ uint8_t option,
+ uint16_t size,
+ uint32_t* data,
+ unsigned int dsize);
+
+int trb_register_write(uint16_t trb_address,
+ uint16_t reg_address,
+ uint32_t value);
+
+int trb_register_write_mem(uint16_t trb_address,
+ uint16_t reg_address,
+ uint8_t option,
+ const uint32_t* data,
+ uint16_t size);
+
+int trb_read_uid(uint16_t trb_address,
+ uint32_t* data,
+ unsigned int dsize);
+
+int trb_set_address(uint64_t uid,
+ uint8_t endpoint,
+ uint16_t trb_address);
+
+
+int trb_ipu_data_read(uint8_t type,
+ uint8_t trg_info,
+ uint8_t trg_random,
+ uint16_t trg_number,
+ uint32_t* data,
+ unsigned int dsize);
+
+int trb_send_trigger(uint8_t type,
+ uint32_t info,
+ uint8_t random,
+ uint16_t number);
+
+int trb_send_trigger_rich(uint8_t input,
+ uint8_t type,
+ uint32_t info,
+ uint8_t random,
+ uint16_t number);
+
+int fpga_register_read(uint16_t reg_address, uint32_t* value);
+
+int fpga_register_write(uint16_t reg_address, uint32_t value);
+
+int trb_fifo_flush(uint8_t channel);
+
+int network_reset();
+
+int com_reset();
+
+int trb_register_modify(uint16_t trb_address,
+ uint16_t reg_address,
+ int mode,
+ uint32_t bitMask,
+ uint32_t bitValue);
+
+/* ---------------------------------------------------------------------- */
+
+/* This library provides several function to access the trbnet on a
+ Etrax-Board.
+
+*/
+
+/************************************************************************/
+/* In case of any error the gloabl varianble 'trb_errno' will be set, */
+/* see trberror.h for details. */
+/************************************************************************/
+
+
+/************************************************************************/
+/* int trb_register_read(uint16_t trb_address,
+ uint16_t reg_address,
+ uint32_t* data,
+ unsigned int dsize);
+
+ trb_address: TRB-Address of the TRB-Endpoint
+ reg_address: Register-Address to be read from, broadcasts are supported
+ data: Pointer to a uint32_t Data-Buffer
+ dsize: Size of the Data-Buffer in units of 32bit-words
+
+ ReturnValue: == -1 on error, trberrno will be set
+ >= 0 number of 32bit-words which were stored in Data-Buffer
+
+ TRB-Channel used: slow control (3)
+
+ reads the register reg_address of a TRB-Endpoint with address
+ trb_address. The received data is stored in the Data-Buffer data.
+
+ The format of the Data-Buffer is:
+ first word: TRB-Address of the sender
+ second word: register value
+
+ --> The size of the Data-Buffer must be at least >= 2
+
+*/
+
+
+/************************************************************************/
+/* int trb_register_read_mem(uint16_t trb_address,
+ uint16_t reg_address,
+ uint8_t option,
+ uint16_t size,
+ uint32_t* data,
+ unsigned int dsize);
+
+ trb_address: TRB-Address of the TRB-Endpoint
+ reg_address: Register-Address to be read from, broadcasts are supported
+ uint8_t option:
+ uint16_t size: Number of 32Bit-words to be read
+ data: Pointer to a uint32_t Data-Buffer
+ dsize: Size of the Data-Buffer in units of 32bit-words
+
+ ReturnValue: == -1 on error, trberrno will be set
+ >= 0 number of 32bit-words which were stored in Data-Buffer
+
+ TRB-Channel used: slow control (3)
+
+ reads the register reg_address of a TRB-Endpoint with address
+ trb_address. The received data is stored in the Data-Buffer data.
+
+ The format of the Data-Buffer is:
+ first word: TRB-Address of the sender (Lower 2Bytes), len (Upper 2bytes)
+ second word: register value
+
+ --> The size of the Data-Buffer must be at least >= 2
+
+*/
+
+
+/************************************************************************/
+/* int trb_register_write(uint16_t trb_address,
+ uint16_t reg_address,
+ uint32_t value);
+
+ trb_address: TRB-Address of the TRB-Endpoint, broadcasts are supported
+ reg_address: Register-Address to be written to
+ value: 32bit-word to be writen to the register
+
+ ReturnValue: == -1 on error, trberrno will be set
+
+ TRB-Channel used: slow control (3)
+
+ writes the value to the register reg_address of a TRB-Endpoint with address
+ trb_address.
+*/
+
+/************************************************************************/
+/* int trb_read_uid(uint16_t trb_address,
+ uint32_t* data,
+ unsigned int dsize);
+
+ trb_address: TRB-Address of the TRB-Endpoint, broadcasts are supported
+ data: Pointer to a uint32_t Data-Buffer
+ dsize: Size of the Data-Buffer in units of 32bit-words
+
+ ReturnValue: == -1 on error, trberrno will be set
+ >= 0 number of 32bit-words which were stored in Data-Buffer
+
+ TRB-Channel used: slow control (3)
+
+ reads the Unique-Id of a TRB-Endpoint with address trb_address. The
+ received data is stored in the Data-Buffer data.
+
+ The format of the Data-Buffer is:
+ first word: UID High-32Bit Word
+ second word: UID Low-32Bit Word
+ third word: Endpoint Number
+ fourth word: TRB-Address of the sender
+
+ --> The size of the Data-Buffer must be at least >= 4
+
+*/
+
+/************************************************************************/
+/* int trb_set_address(uint64_t uid,
+ uint8_t endpoint,
+ uint16_t trb_address);
+
+ uint64_t uid: the UID of the Endpoint
+ uint8_t endpoint: Number of the TRBNet-Endpoint
+ uint16_t trb_address: the new TRB-Netaddress, broadcasts are not supported
+
+ ReturnValue: == -1 on error, trberrno will be set
+ == 0 on success
+
+ TRB-Channel used: slow control (3)
+
+ sets a new TRB-Address trb_address of the give TRFNet-endpoint.
+*/
+
+/************************************************************************/
+/* int trb_ipu_data_read(uint8_t type,
+ uint8_t trg_info,
+ uint8_t trg_random,
+ uint16_t trg_number,
+ uint32_t* data,
+ unsigned int dsize);
+
+ data: Pointer to a uint32_t Data-Buffer
+ dsize: Size of the Data-Buffer in units of 32bit-words
+
+ ReturnValue: == -1 on error, trberrno will be set
+ >= 0 0 number of 32bit-words which were stored in Data-Buffer
+
+ send a request to all TRBNet-Endpoints to readout the IPU-Data. The IPU
+ Datastream will be stored in the user DataBufer.
+*/
+
+/************************************************************************/
+/* int trb_send_trigger(uint8_t type,
+ uint32_t info,
+ uint8_t random,
+ uint16_t number);
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/* initTrace.c */
+
+/*
+ * An initHook routine to trace the iocInit() process.
+ * Prints out the name of each state as it is reached.
+ */
+
+#include <stdio.h>
+
+#include "initHooks.h"
+#include "epicsExport.h"
+#include "iocsh.h"
+
+
+static void trace(initHookState state) {
+ printf("iocInit: Reached %s\n", initHookName(state));
+}
+
+int traceIocInit(void) {
+ static int done = 0;
+ if (done)
+ return -1;
+ done = 1;
+
+ initHookRegister(trace);
+ puts("iocInit will be traced");
+ return 0;
+}
+
+
+static const iocshFuncDef traceInitFuncDef = {"traceIocInit", 0, NULL};
+static void traceInitFunc(const iocshArgBuf *args) {
+ traceIocInit();
+}
+
+static void initTraceRegister(void) {
+ iocshRegister(&traceInitFuncDef, traceInitFunc);
+}
+epicsExportRegistrar(initTraceRegister);
--- /dev/null
+registrar(initTraceRegister)
--- /dev/null
+#include <vxWorks.h>\r
+#include <string.h>\r
+#include <types.h>\r
+#include <math.h>\r
+#include <time.h>\r
+#include <stdlib.h>\r
+#include <stdioLib.h>\r
+\r
+#include <dbEvent.h>\r
+#include <dbDefs.h>\r
+#include <dbCommon.h>\r
+#include <recSup.h>\r
+#include <genSubRecord.h>\r
+\r
+long scalerN_init( struct genSubRecord *pgsub )\r
+{\r
+ return( 0 );\r
+}\r
+\r
+long scalerN_proc( struct genSubRecord *pgsub )\r
+{\r
+/* BK this routine performs the scaler summing and profiles for a up to 16 channel array */\r
+ long *ptr[16], *out[19];\r
+ int nelm,iscal,jchan,nscal;\r
+ long totsum,sum;\r
+/* long sum_arr[100];\r
+ float pos_arr[100];*/\r
+ float pos;\r
+ float *pos_out;\r
+\r
+ ptr[0]= (long *)pgsub->a; /* input arrays*/\r
+ ptr[1]= (long *)pgsub->b;\r
+ ptr[2]= (long *)pgsub->c;\r
+ ptr[3]= (long *)pgsub->d;\r
+ ptr[4]= (long *)pgsub->e;\r
+ ptr[5]= (long *)pgsub->f;\r
+ ptr[6]= (long *)pgsub->g;\r
+ ptr[7]= (long *)pgsub->h;\r
+ ptr[8]= (long *)pgsub->i;\r
+ ptr[9]= (long *)pgsub->j;\r
+ ptr[10]= (long *)pgsub->k;\r
+ ptr[11]= (long *)pgsub->l;\r
+ ptr[12]= (long *)pgsub->m;\r
+ ptr[13]= (long *)pgsub->n;\r
+ ptr[14]= (long *)pgsub->o;\r
+ ptr[15]= (long *)pgsub->p;\r
+ \r
+ out[0]= (long *)pgsub->vala; /* output (0 - 7) A to H are for sums of input arrays*/\r
+ out[1]= (long *)pgsub->valb;\r
+ out[2]= (long *)pgsub->valc;\r
+ out[3]= (long *)pgsub->vald;\r
+ out[4]= (long *)pgsub->vale;\r
+ out[5]= (long *)pgsub->valf;\r
+ out[6]= (long *)pgsub->valg;\r
+ out[7]= (long *)pgsub->valh;\r
+ out[8]= (long *)pgsub->vali;\r
+ out[9]= (long *)pgsub->valj;\r
+ out[10]= (long *)pgsub->valk;\r
+ out[11]= (long *)pgsub->vall;\r
+ out[12]= (long *)pgsub->valm;\r
+ out[13]= (long *)pgsub->valn;\r
+ out[14]= (long *)pgsub->valo;\r
+ out[15]= (long *)pgsub->valp;\r
+ out[16]= (long *)pgsub->valq; /* output (16) I are for across sums of input arrays*/\r
+ pos_out= (float *)pgsub->valr; /* output (17) J is for weighted mean of inputs, array of same length*/\r
+ out[17]= (long *)pgsub->vals; /* output (18) K is profile array, dim max 16*/\r
+ out[18]= (long *)pgsub->valt; /* output (19) L is total sum of input arrays*/\r
+\r
+ nelm= pgsub->noa;\r
+ nscal= pgsub->nou;\r
+ totsum=0;\r
+ for(iscal=0; iscal<nscal; iscal++)\r
+ {\r
+ sum=0;\r
+ for(jchan=0; jchan < nelm; jchan++)\r
+ {\r
+ sum += *(ptr[iscal]++);\r
+ }\r
+ *out[iscal] = sum;\r
+ *(out[17]++) = sum;\r
+ totsum += sum;\r
+ }\r
+ *out[18] = totsum;\r
+\r
+ ptr[0]= (long *)pgsub->a;\r
+ ptr[1]= (long *)pgsub->b;\r
+ ptr[2]= (long *)pgsub->c;\r
+ ptr[3]= (long *)pgsub->d;\r
+ ptr[4]= (long *)pgsub->e;\r
+ ptr[5]= (long *)pgsub->f;\r
+ ptr[6]= (long *)pgsub->g;\r
+ ptr[7]= (long *)pgsub->h;\r
+ ptr[8]= (long *)pgsub->i;\r
+ ptr[9]= (long *)pgsub->j;\r
+ ptr[10]= (long *)pgsub->k;\r
+ ptr[11]= (long *)pgsub->l;\r
+ ptr[12]= (long *)pgsub->m;\r
+ ptr[13]= (long *)pgsub->n;\r
+ ptr[14]= (long *)pgsub->o;\r
+ ptr[15]= (long *)pgsub->p;\r
+ \r
+ for(jchan=0; jchan < nelm; jchan++)\r
+ {\r
+ sum = 0;\r
+ pos = 0.;\r
+ for(iscal=0; iscal<nscal; iscal++)\r
+ {\r
+ sum += *(ptr[iscal]);\r
+ pos += iscal * (*(ptr[iscal]++));\r
+ }\r
+ if( sum > 0 )\r
+ pos = pos / sum;\r
+ else\r
+ pos = (nscal-1)/2.;\r
+ *(out[16]++) = sum;\r
+ *pos_out++ = pos;\r
+ }\r
+\r
+ return(totsum);\r
+}\r
+\r
--- /dev/null
+#include <vxWorks.h>\r
+#include <string.h>\r
+#include <types.h>\r
+#include <math.h>\r
+#include <time.h>\r
+#include <stdlib.h>\r
+#include <stdioLib.h>\r
+\r
+#include <dbEvent.h>\r
+#include <dbDefs.h>\r
+#include <dbCommon.h>\r
+#include <recSup.h>\r
+#include <genSubRecord.h>\r
+\r
+long scaler_rat_init( struct genSubRecord *pgsub )\r
+{\r
+ return( 0 );\r
+}\r
+\r
+long scaler_rat_proc( struct genSubRecord *pgsub )\r
+{\r
+/* BK this routine performs the scaler ratios */\r
+ long *ptr[2];\r
+ int nelm, jchan;\r
+/* long sum_arr[100];\r
+ float pos_arr[100];*/\r
+ float pos, sum;\r
+ float *pos_out; /* ratio output */\r
+\r
+ ptr[0]= (long *)pgsub->a; /* input arrays*/\r
+ ptr[1]= (long *)pgsub->b; /* divide A by B */\r
+ \r
+ pos_out= (float *)pgsub->vala; /* output (1) A is for ratio of inputs, array of same length*/\r
+\r
+ nelm= pgsub->noa;\r
+ for(jchan=0; jchan < nelm; jchan++)\r
+ {\r
+ sum = *(ptr[1]++);\r
+ pos = *(ptr[0]++);\r
+ if( sum > 0 )\r
+ pos = pos / sum;\r
+ else\r
+ pos = 0.;\r
+ *pos_out++ = pos;\r
+ }\r
+\r
+ return(0);\r
+}\r
+\r
--- /dev/null
+registrar(sncExampleRegistrar)
--- /dev/null
+program sncExample
+double v;
+assign v to "{user}:aiExample";
+monitor v;
+
+ss ss1 {
+ state init {
+ when (delay(10)) {
+ printf("sncExample: Startup delay over\n");
+ } state low
+ }
+ state low {
+ when (v > 5.0) {
+ printf("sncExample: Changing to high\n");
+ } state high
+ }
+ state high {
+ when (v <= 5.0) {
+ printf("sncExample: Changing to low\n");
+ } state low
+ }
+}
--- /dev/null
+#include "../sncExample.stt"
--- /dev/null
+/* Example showing how to register a new command with iocsh */
+
+#include <stdio.h>
+
+#include <epicsExport.h>
+#include <iocsh.h>
+
+/* This is the command, which the vxWorks shell will call directly */
+void hello(const char *name) {
+ if (name) {
+ printf("Hello %s, from trb\n", name);
+ } else {
+ puts("Hello from trb");
+ }
+}
+
+/* Information needed by iocsh */
+static const iocshArg helloArg0 = {"name", iocshArgString};
+static const iocshArg *helloArgs[] = {&helloArg0};
+static const iocshFuncDef helloFuncDef = {"hello", 1, helloArgs};
+
+/* Wrapper called by iocsh, selects the argument types that hello needs */
+static void helloCallFunc(const iocshArgBuf *args) {
+ hello(args[0].sval);
+}
+
+/* Registration routine, runs at startup */
+static void helloRegister(void) {
+ iocshRegister(&helloFuncDef, helloCallFunc);
+}
+epicsExportRegistrar(helloRegister);
--- /dev/null
+registrar(helloRegister)
--- /dev/null
+/* trbMain.cpp */
+/* Author: Marty Kraimer Date: 17MAR2000 */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "epicsExit.h"
+#include "epicsThread.h"
+#include "iocsh.h"
+
+int main(int argc,char *argv[])
+{
+ if(argc>=2) {
+ iocsh(argv[1]);
+ epicsThreadSleep(.2);
+ }
+ iocsh(NULL);
+ epicsExit(0);
+ return(0);
+}
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <dbDefs.h>
+#include <registryFunction.h>
+#include <subRecord.h>
+#include <aSubRecord.h>
+#include <epicsExport.h>
+#include <epicsExit.h>
+#include <ctype.h>
+#include <libgen.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <trbnet.h>
+#include <trberror.h>
+#include <sys/types.h>
+
+int mySubDebug, trb_inited=0;
+
+int oepVoltage[8][6][4][16]; /* voltage, sector, plane, mbo */
+
+/*static uint16_t tcp_port = 55555;*/
+/*static void atexit0(void *arg);*/
+
+static long mytrbInit(aSubRecord *precord)
+{
+ if(trb_inited == 0) {
+ if (mySubDebug)
+ printf("Record %s called mytrbInit(%p)\n",
+ precord->name, (void*) precord);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet %d\n", trb_errno);
+ trb_inited = 0;
+ }
+ else
+ trb_inited=1;
+/* install exit handler
+ epicsAtExit(atexit0,0);*/
+ }
+
+ return 0;
+}
+static long oepInit(subRecord *precord)
+{
+ if(trb_inited == 0) {
+ if (mySubDebug)
+ printf("Record %s called oepInit(%p)\n",
+ precord->name, (void*) precord);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet %d\n", trb_errno);
+ trb_inited = 0;
+ }
+ else
+ trb_inited=1;
+ }
+
+ return 0;
+}
+
+static long mytrbUid(aSubRecord *precord)
+{
+ uint16_t trb_address;
+ int status;
+ uint32_t uidBuffer[4];
+ if(trb_inited == 0) {
+ status = sleep(3);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet\n");
+ trb_inited = 0;
+ precord->val = -1;
+ return -1;
+ }
+ else
+ trb_inited=1;
+ }
+ trb_address = *(long*) precord->a;
+ if (mySubDebug)
+ printf("Record %s called mytrbUid(%p) A=0x%X\n",
+ precord->name, (void*) precord, trb_address);
+
+ status = trb_read_uid(trb_address, uidBuffer, 4);
+ if (status == -1) {
+ printf( "read_uid failed: %d %s\n",trb_errno,
+ trb_strerror());
+ trb_inited = 0;
+ } else {
+ printf( "0x%04x 0x%08x 0x%08x 0x%02x\n",
+ uidBuffer[3],
+ uidBuffer[0], uidBuffer[1], uidBuffer[2]);
+ *(uint32_t *)precord->vala=uidBuffer[0];
+ *(uint32_t *)precord->valb=uidBuffer[1];
+ *(uint32_t *)precord->valc=uidBuffer[2];
+
+ }
+
+ return 0;
+}
+static long mytrbRead(aSubRecord *precord)
+{
+ uint16_t trb_address, reg_address;
+ int status, count, i;
+ uint32_t data[2048], *outpa, *outpb;
+ if(trb_inited == 0) {
+ status = sleep(3);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet\n");
+ trb_inited = 0;
+ precord->val = -1;
+ return -1;
+ }
+ else
+ trb_inited=1;
+ }
+ trb_address = *(long*) precord->a;
+ reg_address = *(long*) precord->b;
+ count = *(long*) precord->c;
+ outpa = (uint32_t *)precord->vala;
+ outpb = (uint32_t *)precord->valb;
+ if (mySubDebug)
+ printf("Record %s called mytrbRead(%p) A=0x%X\n",
+ precord->name, (void*) precord, trb_address);
+
+ status = trb_register_read(trb_address, reg_address, data, count*2);
+ if (status == -1) {
+ printf( "read_register failed: %d %s\n",trb_errno,
+ trb_strerror());
+ trb_inited = 0;
+ return -1;
+ } else {
+ if (mySubDebug) printf("trb 0x%04x reg 0x%04x status %d data %d\n", trb_address, reg_address,
+ status,data[0]);
+ for (i = 0; i < status; i += 2) {
+ if (mySubDebug) printf("0x%04x 0x%08x\n", data[i], data[i + 1]);
+ *(outpb++)=data[i]; /* address */
+ *(outpa++)=data[i+1]; /* data */
+ }
+ if( status <= precord->novb) {
+ precord->nevb = status;
+ }
+ else {
+ precord->nevb = precord->novb;
+ }
+ if( status <= precord->nova) {
+ precord->neva = status;
+ }
+ else {
+ precord->neva = precord->nova;
+ }
+ precord->val = status;
+ }
+
+ return 0;
+}
+static long mytrbReadMem(aSubRecord *precord)
+{
+ uint16_t trb_address, reg_address;
+ int status, count, i, option;
+ uint32_t data[5010], *outpa;
+ if(trb_inited == 0) {
+ status = sleep(3);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet\n");
+ trb_inited = 0;
+ precord->val = -1;
+ return -1;
+ }
+ else
+ trb_inited=1;
+ }
+ trb_address = *(long*) precord->a;
+ reg_address = *(long*) precord->b;
+ count = *(long*) precord->c;
+ option = *(long*) precord->d;
+ outpa = (uint32_t *)precord->vala;
+ if (mySubDebug)
+ printf("Record %s called mytrbReadMem(%p) A=0x%X\n",
+ precord->name, (void*) precord, trb_address);
+
+ status = trb_register_read_mem(trb_address, reg_address, option, count, data, count*2);
+ if (status == -1) {
+ printf( "read_register_mem failed: %d %s\n",trb_errno,
+ trb_strerror());
+ trb_inited = 0;
+ return -1;
+ } else {
+ if (mySubDebug) printf("trb 0x%04x reg 0x%04x status %d data 0x%08x\n", trb_address, reg_address,
+ status,data[0]);
+ for (i = 1; i < status; i++) {
+ if (mySubDebug) printf("0x%04x 0x%08x\n",reg_address+i-1, data[i]);
+ *(outpa++)=data[i]; /* data */
+ }
+ if( status <= precord->nova) {
+ precord->neva = status;
+ }
+ else {
+ precord->neva = precord->nova;
+ }
+ precord->val = status;
+ }
+
+ return 0;
+}
+static long oepReadVoltage(subRecord *precord)
+{
+ uint16_t trb_address, reg_address;
+ int status, count, i, iv, is, ip, im;
+ uint32_t data[2048];
+ /* int oepVoltage[8,6,4,16]; voltage, sector, plane, mbo */
+ if(trb_inited == 0) {
+ status = sleep(3);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet\n");
+ trb_inited = 0;
+ precord->val = -1;
+ return -1;
+ }
+ else
+ trb_inited=1;
+ }
+ trb_address = 0xFFFD; /* OEP broadcast */
+ reg_address = precord->a;
+ iv = precord->b; /* voltage number (0-7) */
+ count = 384;
+ if (mySubDebug)
+ printf("Record %s called oepRead(%p) A=0x%X\n",
+ precord->name, (void*) precord, trb_address);
+ for (is = 0; is < 6; is++) {
+ for (ip = 0; ip < 4; ip++) {
+ for (im = 0; im < 16; im++) {
+ oepVoltage[iv][is][ip][im] = -1;
+ }
+ }
+ }
+ status = trb_register_read(trb_address, reg_address, data, count*2);
+ if (status == -1) {
+ printf( "read_register failed: %d %s\n",trb_errno,
+ trb_strerror());
+ trb_inited = 0;
+ precord->val = -1;
+ return -1;
+ } else {
+ if (mySubDebug) printf("trb 0x%04x reg 0x%04x status %d data %d\n", trb_address, reg_address,
+ status,data[0]);
+ for (i = 0; i < status; i += 2) {
+ if (mySubDebug) printf("i: %d 0x%04x 0x%08x\n", i, data[i], data[i + 1]);
+ ip = (data[i] & 0x0300) >> 8;
+ is = (data[i] & 0x0070) >> 4;
+ im = data[i] & 0x000F;
+ if (mySubDebug) printf("iv: %d ip: %d is: %d im: %d \n", iv,ip,is,im);
+ if(is < 6) oepVoltage[iv][is][ip][im] = data[i + 1];
+ }
+ precord->val = status;
+ }
+ if (mySubDebug) printf("return from oepRead\n");
+
+ return 0;
+}
+static long oepGetVoltage(subRecord *precord)
+{
+ int iv, is, ip, im;
+ /* int oepVoltage[8,6,4,16]; voltage, sector, plane, mbo */
+ iv = precord->a; /* voltage number (0-7) */
+ is = precord->b; /* sector number (0-5) */
+ ip = precord->c; /* plane number (0-3) */
+ im = precord->d; /* mbo number (0-15) */
+ precord->val = oepVoltage[iv][is][ip][im]/1000.;
+ return 0;
+}
+static long mytrbWrite(aSubRecord *precord)
+{
+ uint16_t trb_address, reg_address;
+ int status;
+ uint32_t data;
+ if(trb_inited == 0) {
+ status = sleep(3);
+ if (init_ports() == -1) {
+ printf("error connecting to trbnet\n");
+ trb_inited = 0;
+ precord->val = -1;
+ return -1;
+ }
+ else
+ trb_inited=1;
+ }
+ trb_address = *(long*) precord->a;
+ reg_address = *(long*) precord->b;
+ data = *(long*) precord->c;
+/* if (mySubDebug)*/
+ printf("Record %s called mytrbWrite(%p) A=0x%X R=0x%4x d=0x%x\n",
+ precord->name, (void*) precord, trb_address,reg_address, data);
+
+ status = trb_register_write(trb_address, reg_address, data);
+ if (status == -1) {
+ printf( "write_register failed: %d %s\n",trb_errno,
+ trb_strerror());
+ trb_inited = 0;
+ return -1;
+ }
+
+ return 0;
+}
+
+static long scalerN_init( struct aSubRecord *pgsub )
+{
+ return( 0 );
+}
+
+static long scalerN_proc( struct aSubRecord *pgsub )
+{
+/* BK this routine performs the scaler summing and profiles for a up to 16 channel array */
+ long *ptr[16], *out[19];
+ int nelm,iscal,jchan,nscal;
+ long totsum,sum;
+/* long sum_arr[100];
+ float pos_arr[100];*/
+ float pos;
+ float *pos_out;
+
+ ptr[0]= (long *)pgsub->a; /* input arrays*/
+ ptr[1]= (long *)pgsub->b;
+ ptr[2]= (long *)pgsub->c;
+ ptr[3]= (long *)pgsub->d;
+ ptr[4]= (long *)pgsub->e;
+ ptr[5]= (long *)pgsub->f;
+ ptr[6]= (long *)pgsub->g;
+ ptr[7]= (long *)pgsub->h;
+ ptr[8]= (long *)pgsub->i;
+ ptr[9]= (long *)pgsub->j;
+ ptr[10]= (long *)pgsub->k;
+ ptr[11]= (long *)pgsub->l;
+ ptr[12]= (long *)pgsub->m;
+ ptr[13]= (long *)pgsub->n;
+ ptr[14]= (long *)pgsub->o;
+ ptr[15]= (long *)pgsub->p;
+
+ out[0]= (long *)pgsub->vala; /* output (0 - 7) A to H are for sums of input arrays*/
+ out[1]= (long *)pgsub->valb;
+ out[2]= (long *)pgsub->valc;
+ out[3]= (long *)pgsub->vald;
+ out[4]= (long *)pgsub->vale;
+ out[5]= (long *)pgsub->valf;
+ out[6]= (long *)pgsub->valg;
+ out[7]= (long *)pgsub->valh;
+ out[8]= (long *)pgsub->vali;
+ out[9]= (long *)pgsub->valj;
+ out[10]= (long *)pgsub->valk;
+ out[11]= (long *)pgsub->vall;
+ out[12]= (long *)pgsub->valm;
+ out[13]= (long *)pgsub->valn;
+ out[14]= (long *)pgsub->valo;
+ out[15]= (long *)pgsub->valp;
+ out[16]= (long *)pgsub->valq; /* output (16) I are for across sums of input arrays*/
+ pos_out= (float *)pgsub->valr; /* output (17) J is for weighted mean of inputs, array of same length*/
+ out[17]= (long *)pgsub->vals; /* output (18) K is profile array, dim max 16*/
+ out[18]= (long *)pgsub->valt; /* output (19) L is total sum of input arrays*/
+
+ nelm= pgsub->noa;
+ nscal= pgsub->nou;
+ totsum=0;
+ for(iscal=0; iscal<nscal; iscal++)
+ {
+ sum=0;
+ for(jchan=0; jchan < nelm; jchan++)
+ {
+ sum += *(ptr[iscal]++);
+ }
+ *out[iscal] = sum;
+ *(out[17]++) = sum;
+ totsum += sum;
+ }
+ *out[18] = totsum;
+
+ ptr[0]= (long *)pgsub->a;
+ ptr[1]= (long *)pgsub->b;
+ ptr[2]= (long *)pgsub->c;
+ ptr[3]= (long *)pgsub->d;
+ ptr[4]= (long *)pgsub->e;
+ ptr[5]= (long *)pgsub->f;
+ ptr[6]= (long *)pgsub->g;
+ ptr[7]= (long *)pgsub->h;
+ ptr[8]= (long *)pgsub->i;
+ ptr[9]= (long *)pgsub->j;
+ ptr[10]= (long *)pgsub->k;
+ ptr[11]= (long *)pgsub->l;
+ ptr[12]= (long *)pgsub->m;
+ ptr[13]= (long *)pgsub->n;
+ ptr[14]= (long *)pgsub->o;
+ ptr[15]= (long *)pgsub->p;
+
+ for(jchan=0; jchan < nelm; jchan++)
+ {
+ sum = 0;
+ pos = 0.;
+ for(iscal=0; iscal<nscal; iscal++)
+ {
+ sum += *(ptr[iscal]);
+ pos += iscal * (*(ptr[iscal]++));
+ }
+ if( sum > 0 )
+ pos = pos / sum;
+ else
+ pos = (nscal-1)/2.;
+ *(out[16]++) = sum;
+ *pos_out++ = pos;
+ }
+
+ return(totsum);
+}
+
+static long scalerN_copy( struct aSubRecord *pgsub )
+{
+/* BK this routine performs the scaler EXTRACTION */
+ long *ptr, *out[19];
+ int nelm,iscal,jchan,nscal;
+
+ ptr = (long *)pgsub->a; /* input array*/
+ nscal= pgsub->noa; /* input length */
+ jchan= *(long *)pgsub->c; /*offset */
+ nelm= *(long *)pgsub->d; /*output length */
+ if (mySubDebug) {
+ printf("Record %s called scalerN_copy(%p) \n",pgsub->name, (void*) pgsub);
+ printf(" nscal %d jchan %d nelm %d \n", nscal,jchan,nelm);
+ }
+ out[0]= (long *)pgsub->vala; /* */
+ out[1]= (long *)pgsub->valb;
+ out[2]= (long *)pgsub->valc;
+ out[3]= (long *)pgsub->vald;
+ out[4]= (long *)pgsub->vale;
+ out[5]= (long *)pgsub->valf;
+ out[6]= (long *)pgsub->valg;
+ out[7]= (long *)pgsub->valh;
+ out[8]= (long *)pgsub->vali;
+ out[9]= (long *)pgsub->valj;
+ out[10]= (long *)pgsub->valk;
+ out[11]= (long *)pgsub->vall;
+ out[12]= (long *)pgsub->valm;
+ out[13]= (long *)pgsub->valn;
+ out[14]= (long *)pgsub->valo;
+ out[15]= (long *)pgsub->valp;
+ out[16]= (long *)pgsub->valq;
+ out[17]= (long *)pgsub->valr;
+ out[18]= (long *)pgsub->vals;
+
+ for(iscal=0; iscal<nelm; iscal++)
+ {
+ *out[iscal] = *(ptr + jchan+iscal);
+ }
+ return(0);
+
+}
+
+static long scaler_rat_init( struct aSubRecord *pgsub )
+{
+ return( 0 );
+}
+
+static long scaler_rat_proc( struct aSubRecord *pgsub )
+{
+/* BK this routine performs the scaler ratios */
+ long *ptr[2];
+ int nelm, jchan;
+/* long sum_arr[100];
+ float pos_arr[100];*/
+ float pos, sum;
+ float *pos_out; /* ratio output */
+
+ ptr[0]= (long *)pgsub->a; /* input arrays*/
+ ptr[1]= (long *)pgsub->b; /* divide A by B */
+
+ pos_out= (float *)pgsub->vala; /* output (1) A is for ratio of inputs, array of same length*/
+
+ nelm= pgsub->noa;
+ for(jchan=0; jchan < nelm; jchan++)
+ {
+ sum = *(ptr[1]++);
+ pos = *(ptr[0]++);
+ if( sum > 0 )
+ pos = pos / sum;
+ else
+ pos = 0.;
+ *pos_out++ = pos;
+ }
+
+ return(0);
+}
+static long ctsRegInit( struct aSubRecord *precord )
+{
+ return( 0 );
+}
+static long ctsRegSplit( struct aSubRecord *precord )
+{
+ uint32_t data, *outpa, *outpb;
+ data = *(long*) precord->a;
+ outpa = (uint32_t *)precord->vala;
+ outpb = (uint32_t *)precord->valb;
+ *outpa = 0xffff & data ;
+ *outpb = 0xffff & (data >> 16);
+
+ return( 0 );
+}
+static long ctsRegUnsplit( struct aSubRecord *precord )
+{
+ uint32_t ina,inb, *outpa;
+ ina = *(long*) precord->a;
+ inb = *(long*) precord->b;
+ outpa = (uint32_t *)precord->vala;
+ *outpa = (0xffff & ina) | ((0xffff & inb) <<16) ;
+
+ return( 0 );
+}
+static long ctsRegSplit4( struct aSubRecord *precord )
+{
+ uint32_t data, *outpa, *outpb, *outpc, *outpd;
+ data = *(long*) precord->a;
+ outpa = (uint32_t *)precord->vala;
+ outpb = (uint32_t *)precord->valb;
+ outpc = (uint32_t *)precord->valc;
+ outpd = (uint32_t *)precord->vald;
+ *outpa = 0xff & data ;
+ *outpb = 0xff & (data >> 8);
+ *outpc = 0xff & (data >> 16);
+ *outpd = 0xff & (data >> 24);
+
+ return( 0 );
+}
+static long ctsRegUnsplit4( struct aSubRecord *precord )
+{
+ uint32_t ina,inb,inc,ind, *outpa;
+ ina = *(long*) precord->a;
+ inb = *(long*) precord->b;
+ inc = *(long*) precord->c;
+ ind = *(long*) precord->d;
+ outpa = (uint32_t *)precord->vala;
+ *outpa = (0xff & ina) | ((0xff & inb) <<8)| ((0xff & inc) <<16)| ((0xff & ind) <<24) ;
+
+ return( 0 );
+}
+static long ctsRegSplit8( struct aSubRecord *precord )
+{
+ uint32_t data, *outpa, *outpb, *outpc, *outpd;
+ uint32_t *outpe, *outpf, *outpg, *outph;
+ data = *(long*) precord->a;
+ outpa = (uint32_t *)precord->vala;
+ outpb = (uint32_t *)precord->valb;
+ outpc = (uint32_t *)precord->valc;
+ outpd = (uint32_t *)precord->vald;
+ outpe = (uint32_t *)precord->vale;
+ outpf = (uint32_t *)precord->valf;
+ outpg = (uint32_t *)precord->valg;
+ outph = (uint32_t *)precord->valh;
+ *outpa = 0xf & data ;
+ *outpb = 0xf & (data >> 4);
+ *outpc = 0xf & (data >> 8);
+ *outpd = 0xf & (data >> 12);
+ *outpe = 0xf & (data >> 16);
+ *outpf = 0xf & (data >> 20);
+ *outpg = 0xf & (data >> 24);
+ *outph = 0xf & (data >> 28);
+
+ return( 0 );
+}
+static long ctsRegUnsplit8( struct aSubRecord *precord )
+{
+ uint32_t ina,inb,inc,ind,ine,inf,ing,inh, *outpa;
+ ina = *(long*) precord->a;
+ inb = *(long*) precord->b;
+ inc = *(long*) precord->c;
+ ind = *(long*) precord->d;
+ ine = *(long*) precord->e;
+ inf = *(long*) precord->f;
+ ing = *(long*) precord->g;
+ inh = *(long*) precord->h;
+ outpa = (uint32_t *)precord->vala;
+ *outpa = (0xf & ina) | ((0xf & inb) <<4)| ((0xf & inc) <<8)| ((0xf & ind) <<12)
+ | ((0xf & ine) <<16)| ((0xf & inf) <<20)| ((0xf & ing) <<24)| ((0xf & inh) <<28) ;
+
+ return( 0 );
+}
+static long WatchInit(subRecord *precord)
+{
+ return 0;
+}
+static long WatchReset(subRecord *precord)
+{
+ printf("Watchdog detected timeout\n");
+ kill(getpid(), 9);
+ return 0;
+}
+
+
+/* Register these symbols for use by IOC code: */
+
+epicsExportAddress(int, mySubDebug);
+epicsRegisterFunction(mytrbInit);
+epicsRegisterFunction(mytrbUid);
+epicsRegisterFunction(mytrbRead);
+epicsRegisterFunction(mytrbReadMem);
+epicsRegisterFunction(mytrbWrite);
+epicsRegisterFunction(oepInit);
+epicsRegisterFunction(oepReadVoltage);
+epicsRegisterFunction(oepGetVoltage);
+epicsRegisterFunction(scalerN_init);
+epicsRegisterFunction(scalerN_proc);
+epicsRegisterFunction(scalerN_copy);
+epicsRegisterFunction(scaler_rat_init);
+epicsRegisterFunction(scaler_rat_proc);
+epicsRegisterFunction(ctsRegInit);
+epicsRegisterFunction(ctsRegSplit);
+epicsRegisterFunction(ctsRegSplit4);
+epicsRegisterFunction(ctsRegSplit8);
+epicsRegisterFunction(ctsRegUnsplit);
+epicsRegisterFunction(ctsRegUnsplit4);
+epicsRegisterFunction(ctsRegUnsplit8);
+epicsRegisterFunction(WatchInit);
+epicsRegisterFunction(WatchReset);
--- /dev/null
+variable(mySubDebug)
+function(mytrbInit)
+function(mytrbUid)
+function(mytrbRead)
+function(mytrbReadMem)
+function(mytrbWrite)
+function(oepInit)
+function(oepReadVoltage)
+function(oepGetVoltage)
+function(scalerN_init)
+function(scalerN_proc)
+function(scalerN_copy)
+function(scaler_rat_init)
+function(scaler_rat_proc)
+function(ctsRegInit)
+function(ctsRegSplit)
+function(ctsRegSplit4)
+function(ctsRegSplit8)
+function(ctsRegUnsplit)
+function(ctsRegUnsplit4)
+function(ctsRegUnsplit8)
+function(WatchInit)
+function(WatchReset)
jspc29 / epics.git / commitdiff