From: P.Zumbruch Date: Wed, 8 May 2013 11:49:13 +0000 (+0200) Subject: initial commit of epics IOC X-Git-Tag: v1~3 X-Git-Url: https://jspc29.x-matter.uni-frankfurt.de/git/?a=commitdiff_plain;h=b68902d6a7fca80a7d3d9a1c51e8ed332da6e5dc;p=epics.git initial commit of epics IOC - built by B.Kolb@gsi.de - to communicate with the trb based CTS module of HADES. --- diff --git a/.cproject b/.cproject new file mode 100644 index 0000000..2c39d81 --- /dev/null +++ b/.cproject @@ -0,0 +1,51 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..48bf463 --- /dev/null +++ b/.project @@ -0,0 +1,27 @@ + + + epics + + + + + + org.eclipse.cdt.managedbuilder.core.genmakebuilder + clean,full,incremental, + + + + + org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder + full,incremental, + + + + + + org.eclipse.cdt.core.cnature + org.eclipse.cdt.core.ccnature + org.eclipse.cdt.managedbuilder.core.managedBuildNature + org.eclipse.cdt.managedbuilder.core.ScannerConfigNature + + diff --git a/Trbnet/trbnetIoc/Makefile b/Trbnet/trbnetIoc/Makefile new file mode 100644 index 0000000..f0d9ad7 --- /dev/null +++ b/Trbnet/trbnetIoc/Makefile @@ -0,0 +1,17 @@ +#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 + + diff --git a/Trbnet/trbnetIoc/configure/CONFIG b/Trbnet/trbnetIoc/configure/CONFIG new file mode 100644 index 0000000..c1a4703 --- /dev/null +++ b/Trbnet/trbnetIoc/configure/CONFIG @@ -0,0 +1,29 @@ +# 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 + diff --git a/Trbnet/trbnetIoc/configure/CONFIG_SITE b/Trbnet/trbnetIoc/configure/CONFIG_SITE new file mode 100644 index 0000000..72b399d --- /dev/null +++ b/Trbnet/trbnetIoc/configure/CONFIG_SITE @@ -0,0 +1,33 @@ +# 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= + +# 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 = diff --git a/Trbnet/trbnetIoc/configure/Makefile b/Trbnet/trbnetIoc/configure/Makefile new file mode 100644 index 0000000..9254309 --- /dev/null +++ b/Trbnet/trbnetIoc/configure/Makefile @@ -0,0 +1,8 @@ +TOP=.. + +include $(TOP)/configure/CONFIG + +TARGETS = $(CONFIG_TARGETS) +CONFIGS += $(subst ../,,$(wildcard $(CONFIG_INSTALLS))) + +include $(TOP)/configure/RULES diff --git a/Trbnet/trbnetIoc/configure/RELEASE b/Trbnet/trbnetIoc/configure/RELEASE new file mode 100644 index 0000000..af9df3b --- /dev/null +++ b/Trbnet/trbnetIoc/configure/RELEASE @@ -0,0 +1,32 @@ +# 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 diff --git a/Trbnet/trbnetIoc/configure/RULES b/Trbnet/trbnetIoc/configure/RULES new file mode 100644 index 0000000..6d56e14 --- /dev/null +++ b/Trbnet/trbnetIoc/configure/RULES @@ -0,0 +1,6 @@ +# RULES + +include $(CONFIG)/RULES + +# Library should be rebuilt because LIBOBJS may have changed. +$(LIBNAME): ../Makefile diff --git a/Trbnet/trbnetIoc/configure/RULES.ioc b/Trbnet/trbnetIoc/configure/RULES.ioc new file mode 100644 index 0000000..901987c --- /dev/null +++ b/Trbnet/trbnetIoc/configure/RULES.ioc @@ -0,0 +1,2 @@ +#RULES.ioc +include $(CONFIG)/RULES.ioc diff --git a/Trbnet/trbnetIoc/configure/RULES_DIRS b/Trbnet/trbnetIoc/configure/RULES_DIRS new file mode 100644 index 0000000..3ba269d --- /dev/null +++ b/Trbnet/trbnetIoc/configure/RULES_DIRS @@ -0,0 +1,2 @@ +#RULES_DIRS +include $(CONFIG)/RULES_DIRS diff --git a/Trbnet/trbnetIoc/configure/RULES_TOP b/Trbnet/trbnetIoc/configure/RULES_TOP new file mode 100644 index 0000000..d09d668 --- /dev/null +++ b/Trbnet/trbnetIoc/configure/RULES_TOP @@ -0,0 +1,3 @@ +#RULES_TOP +include $(CONFIG)/RULES_TOP + diff --git a/Trbnet/trbnetIoc/iocBoot/Makefile b/Trbnet/trbnetIoc/iocBoot/Makefile new file mode 100644 index 0000000..91e47d0 --- /dev/null +++ b/Trbnet/trbnetIoc/iocBoot/Makefile @@ -0,0 +1,6 @@ +TOP = .. +include $(TOP)/configure/CONFIG +DIRS += $(wildcard *ioc*) +DIRS += $(wildcard as*) +include $(CONFIG)/RULES_DIRS + diff --git a/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/Makefile b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/Makefile new file mode 100644 index 0000000..cec9156 --- /dev/null +++ b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/Makefile @@ -0,0 +1,5 @@ +TOP = ../.. +include $(TOP)/configure/CONFIG +ARCH = linux-x86 +TARGETS = envPaths +include $(TOP)/configure/RULES.ioc diff --git a/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/README b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/README new file mode 100644 index 0000000..65c4835 --- /dev/null +++ b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/README @@ -0,0 +1,9 @@ +To start the ioc from this directory execute the command + ../../bin/linux-x86/ 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. diff --git a/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/envPaths b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/envPaths new file mode 100644 index 0000000..d7a0521 --- /dev/null +++ b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/envPaths @@ -0,0 +1,6 @@ +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") diff --git a/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/pid.txt b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/pid.txt new file mode 100644 index 0000000..a0a24b0 --- /dev/null +++ b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/pid.txt @@ -0,0 +1 @@ +13230 diff --git a/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/st.cmd b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/st.cmd new file mode 100644 index 0000000..a540637 --- /dev/null +++ b/Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/st.cmd @@ -0,0 +1,34 @@ +#!../../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" diff --git a/Trbnet/trbnetIoc/trbApp/Db/Makefile b/Trbnet/trbnetIoc/trbApp/Db/Makefile new file mode 100644 index 0000000..493b312 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/Makefile @@ -0,0 +1,29 @@ +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 .db template is not named *.template add +# _TEMPLATE = + +include $(TOP)/configure/RULES +#---------------------------------------- +# ADD RULES AFTER THIS LINE + diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsBeamstruct.db b/Trbnet/trbnetIoc/trbApp/Db/ctsBeamstruct.db new file mode 100644 index 0000000..5466800 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsBeamstruct.db @@ -0,0 +1,195 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsMux.template b/Trbnet/trbnetIoc/trbApp/Db/ctsMux.template new file mode 100644 index 0000000..143c27a --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsMux.template @@ -0,0 +1,37 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegByte.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegByte.template new file mode 100644 index 0000000..3a855f6 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegByte.template @@ -0,0 +1,131 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegByteScaled.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegByteScaled.template new file mode 100644 index 0000000..51e2a78 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegByteScaled.template @@ -0,0 +1,251 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegC1.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegC1.template new file mode 100644 index 0000000..49027ff --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegC1.template @@ -0,0 +1,122 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegCombi.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegCombi.template new file mode 100644 index 0000000..eb2f619 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegCombi.template @@ -0,0 +1,287 @@ +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") +} + diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegHiLo.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegHiLo.template new file mode 100644 index 0000000..2c135e2 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegHiLo.template @@ -0,0 +1,108 @@ +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") +} + diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegNibble.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegNibble.template new file mode 100644 index 0000000..01a7982 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegNibble.template @@ -0,0 +1,219 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegNibbleScaled.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegNibbleScaled.template new file mode 100644 index 0000000..17ccf0c --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegNibbleScaled.template @@ -0,0 +1,482 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegRead.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegRead.template new file mode 100644 index 0000000..975d631 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegRead.template @@ -0,0 +1,192 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegRead1.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegRead1.template new file mode 100644 index 0000000..458c5c7 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegRead1.template @@ -0,0 +1,65 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegSimple.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegSimple.template new file mode 100644 index 0000000..75db5fd --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegSimple.template @@ -0,0 +1,32 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegSimpleScaled.template b/Trbnet/trbnetIoc/trbApp/Db/ctsRegSimpleScaled.template new file mode 100644 index 0000000..1f6c230 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegSimpleScaled.template @@ -0,0 +1,63 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsRegister.substitutions b/Trbnet/trbnetIoc/trbApp/Db/ctsRegister.substitutions new file mode 100644 index 0000000..be2ce3f --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsRegister.substitutions @@ -0,0 +1,88 @@ +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} +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsScaler.substitutions b/Trbnet/trbnetIoc/trbApp/Db/ctsScaler.substitutions new file mode 100644 index 0000000..c02fd4d --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsScaler.substitutions @@ -0,0 +1,101 @@ +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} +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsScalerRead.template b/Trbnet/trbnetIoc/trbApp/Db/ctsScalerRead.template new file mode 100644 index 0000000..1ae02ce --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsScalerRead.template @@ -0,0 +1,303 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/ctsScalerSingle.template b/Trbnet/trbnetIoc/trbApp/Db/ctsScalerSingle.template new file mode 100644 index 0000000..0749dda --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/ctsScalerSingle.template @@ -0,0 +1,55 @@ +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") +} diff --git a/Trbnet/trbnetIoc/trbApp/Db/dbExample1.db b/Trbnet/trbnetIoc/trbApp/Db/dbExample1.db new file mode 100644 index 0000000..2b5a576 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/Db/dbExample1.db @@ -0,0 +1,48 @@ +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/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 /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 + diff --git a/Trbnet/trbnetIoc/trbApp/src/dbSubExample.c b/Trbnet/trbnetIoc/trbApp/src/dbSubExample.c new file mode 100644 index 0000000..1cc748b --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/dbSubExample.c @@ -0,0 +1,49 @@ +#include + +#include +#include +#include +#include +#include + +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); diff --git a/Trbnet/trbnetIoc/trbApp/src/dbSubExample.dbd b/Trbnet/trbnetIoc/trbApp/src/dbSubExample.dbd new file mode 100644 index 0000000..5f6e40a --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/dbSubExample.dbd @@ -0,0 +1,5 @@ +variable(mySubDebug) +function(mySubInit) +function(mySubProcess) +function(myAsubInit) +function(myAsubProcess) diff --git a/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trberror.h b/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trberror.h new file mode 100644 index 0000000..c69cad7 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trberror.h @@ -0,0 +1,66 @@ +#ifndef TRBERROR_H +#define TRBERROR_H + +#include + +#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 diff --git a/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trbnet.h b/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trbnet.h new file mode 100644 index 0000000..48967b2 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trbnet.h @@ -0,0 +1,262 @@ +#ifndef TRBNET_H +#define TRBNET_H + +extern const char trbnet_version[]; + +#include +#include + +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 diff --git a/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/lib/linux-x86/libtrbnet.a b/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/lib/linux-x86/libtrbnet.a new file mode 100644 index 0000000..b1b9d4f Binary files /dev/null and b/Trbnet/trbnetIoc/trbApp/src/extern/trbnet/lib/linux-x86/libtrbnet.a differ diff --git a/Trbnet/trbnetIoc/trbApp/src/initTrace.c b/Trbnet/trbnetIoc/trbApp/src/initTrace.c new file mode 100644 index 0000000..50bc8e8 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/initTrace.c @@ -0,0 +1,39 @@ +/* initTrace.c */ + +/* + * An initHook routine to trace the iocInit() process. + * Prints out the name of each state as it is reached. + */ + +#include + +#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); diff --git a/Trbnet/trbnetIoc/trbApp/src/initTrace.dbd b/Trbnet/trbnetIoc/trbApp/src/initTrace.dbd new file mode 100644 index 0000000..8083c0a --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/initTrace.dbd @@ -0,0 +1 @@ +registrar(initTraceRegister) diff --git a/Trbnet/trbnetIoc/trbApp/src/scalerN.c b/Trbnet/trbnetIoc/trbApp/src/scalerN.c new file mode 100644 index 0000000..909799d --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/scalerN.c @@ -0,0 +1,121 @@ +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +long scalerN_init( struct genSubRecord *pgsub ) +{ + return( 0 ); +} + +long scalerN_proc( struct genSubRecord *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; iscala; + 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 0 ) + pos = pos / sum; + else + pos = (nscal-1)/2.; + *(out[16]++) = sum; + *pos_out++ = pos; + } + + return(totsum); +} + diff --git a/Trbnet/trbnetIoc/trbApp/src/scaler_rat.c b/Trbnet/trbnetIoc/trbApp/src/scaler_rat.c new file mode 100644 index 0000000..9da954a --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/scaler_rat.c @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +long scaler_rat_init( struct genSubRecord *pgsub ) +{ + return( 0 ); +} + +long scaler_rat_proc( struct genSubRecord *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); +} + diff --git a/Trbnet/trbnetIoc/trbApp/src/sncExample.dbd b/Trbnet/trbnetIoc/trbApp/src/sncExample.dbd new file mode 100644 index 0000000..df61066 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/sncExample.dbd @@ -0,0 +1 @@ +registrar(sncExampleRegistrar) diff --git a/Trbnet/trbnetIoc/trbApp/src/sncExample.stt b/Trbnet/trbnetIoc/trbApp/src/sncExample.stt new file mode 100644 index 0000000..235f3f4 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/sncExample.stt @@ -0,0 +1,22 @@ +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 + } +} diff --git a/Trbnet/trbnetIoc/trbApp/src/sncProgram.st b/Trbnet/trbnetIoc/trbApp/src/sncProgram.st new file mode 100644 index 0000000..1ba2989 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/sncProgram.st @@ -0,0 +1 @@ +#include "../sncExample.stt" diff --git a/Trbnet/trbnetIoc/trbApp/src/trbHello.c b/Trbnet/trbnetIoc/trbApp/src/trbHello.c new file mode 100644 index 0000000..4933b6b --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/trbHello.c @@ -0,0 +1,31 @@ +/* Example showing how to register a new command with iocsh */ + +#include + +#include +#include + +/* 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); diff --git a/Trbnet/trbnetIoc/trbApp/src/trbHello.dbd b/Trbnet/trbnetIoc/trbApp/src/trbHello.dbd new file mode 100644 index 0000000..64eb038 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/trbHello.dbd @@ -0,0 +1 @@ +registrar(helloRegister) diff --git a/Trbnet/trbnetIoc/trbApp/src/trbMain.cpp b/Trbnet/trbnetIoc/trbApp/src/trbMain.cpp new file mode 100644 index 0000000..53f92aa --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/trbMain.cpp @@ -0,0 +1,23 @@ +/* trbMain.cpp */ +/* Author: Marty Kraimer Date: 17MAR2000 */ + +#include +#include +#include +#include +#include + +#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); +} diff --git a/Trbnet/trbnetIoc/trbApp/src/trbSub.c b/Trbnet/trbnetIoc/trbApp/src/trbSub.c new file mode 100644 index 0000000..17abe5e --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/trbSub.c @@ -0,0 +1,615 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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; iscala; + 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 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; iscala; /* 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); diff --git a/Trbnet/trbnetIoc/trbApp/src/trbSub.dbd b/Trbnet/trbnetIoc/trbApp/src/trbSub.dbd new file mode 100644 index 0000000..e974d80 --- /dev/null +++ b/Trbnet/trbnetIoc/trbApp/src/trbSub.dbd @@ -0,0 +1,23 @@ +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)