From b68902d6a7fca80a7d3d9a1c51e8ed332da6e5dc Mon Sep 17 00:00:00 2001 From: "P.Zumbruch" Date: Wed, 8 May 2013 13:49:13 +0200 Subject: [PATCH] initial commit of epics IOC - built by B.Kolb@gsi.de - to communicate with the trb based CTS module of HADES. --- .cproject | 51 ++ .project | 27 + Trbnet/trbnetIoc/Makefile | 17 + Trbnet/trbnetIoc/configure/CONFIG | 29 + Trbnet/trbnetIoc/configure/CONFIG_SITE | 33 + Trbnet/trbnetIoc/configure/Makefile | 8 + Trbnet/trbnetIoc/configure/RELEASE | 32 + Trbnet/trbnetIoc/configure/RULES | 6 + Trbnet/trbnetIoc/configure/RULES.ioc | 2 + Trbnet/trbnetIoc/configure/RULES_DIRS | 2 + Trbnet/trbnetIoc/configure/RULES_TOP | 3 + Trbnet/trbnetIoc/iocBoot/Makefile | 6 + .../trbnetIoc/iocBoot/ioclxhadesdaq/Makefile | 5 + Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/README | 9 + .../trbnetIoc/iocBoot/ioclxhadesdaq/envPaths | 6 + .../trbnetIoc/iocBoot/ioclxhadesdaq/pid.txt | 1 + Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/st.cmd | 34 + Trbnet/trbnetIoc/trbApp/Db/Makefile | 29 + Trbnet/trbnetIoc/trbApp/Db/ctsBeamstruct.db | 195 ++++++ Trbnet/trbnetIoc/trbApp/Db/ctsMux.template | 37 ++ .../trbnetIoc/trbApp/Db/ctsRegByte.template | 131 ++++ .../trbApp/Db/ctsRegByteScaled.template | 251 +++++++ Trbnet/trbnetIoc/trbApp/Db/ctsRegC1.template | 122 ++++ .../trbnetIoc/trbApp/Db/ctsRegCombi.template | 287 ++++++++ .../trbnetIoc/trbApp/Db/ctsRegHiLo.template | 108 +++ .../trbnetIoc/trbApp/Db/ctsRegNibble.template | 219 +++++++ .../trbApp/Db/ctsRegNibbleScaled.template | 482 ++++++++++++++ .../trbnetIoc/trbApp/Db/ctsRegRead.template | 192 ++++++ .../trbnetIoc/trbApp/Db/ctsRegRead1.template | 65 ++ .../trbnetIoc/trbApp/Db/ctsRegSimple.template | 32 + .../trbApp/Db/ctsRegSimpleScaled.template | 63 ++ .../trbApp/Db/ctsRegister.substitutions | 88 +++ .../trbApp/Db/ctsScaler.substitutions | 101 +++ .../trbApp/Db/ctsScalerRead.template | 303 +++++++++ .../trbApp/Db/ctsScalerSingle.template | 55 ++ Trbnet/trbnetIoc/trbApp/Db/dbExample1.db | 48 ++ Trbnet/trbnetIoc/trbApp/Db/dbExample2.db | 40 ++ Trbnet/trbnetIoc/trbApp/Db/dbSubExample.db | 13 + Trbnet/trbnetIoc/trbApp/Db/oepRead.db | 72 ++ .../trbnetIoc/trbApp/Db/oepVolt.substitutions | 411 ++++++++++++ Trbnet/trbnetIoc/trbApp/Db/oepVolt.template | 96 +++ Trbnet/trbnetIoc/trbApp/Db/trbExample.db | 202 ++++++ Trbnet/trbnetIoc/trbApp/Db/user.substitutions | 12 + .../trbApp/Db/userHost.substitutions | 12 + Trbnet/trbnetIoc/trbApp/Makefile | 8 + Trbnet/trbnetIoc/trbApp/src/Makefile | 91 +++ Trbnet/trbnetIoc/trbApp/src/dbSubExample.c | 49 ++ Trbnet/trbnetIoc/trbApp/src/dbSubExample.dbd | 5 + .../src/extern/trbnet/include/trberror.h | 66 ++ .../trbApp/src/extern/trbnet/include/trbnet.h | 262 ++++++++ .../extern/trbnet/lib/linux-x86/libtrbnet.a | Bin 0 -> 88830 bytes Trbnet/trbnetIoc/trbApp/src/initTrace.c | 39 ++ Trbnet/trbnetIoc/trbApp/src/initTrace.dbd | 1 + Trbnet/trbnetIoc/trbApp/src/scalerN.c | 121 ++++ Trbnet/trbnetIoc/trbApp/src/scaler_rat.c | 49 ++ Trbnet/trbnetIoc/trbApp/src/sncExample.dbd | 1 + Trbnet/trbnetIoc/trbApp/src/sncExample.stt | 22 + Trbnet/trbnetIoc/trbApp/src/sncProgram.st | 1 + Trbnet/trbnetIoc/trbApp/src/trbHello.c | 31 + Trbnet/trbnetIoc/trbApp/src/trbHello.dbd | 1 + Trbnet/trbnetIoc/trbApp/src/trbMain.cpp | 23 + Trbnet/trbnetIoc/trbApp/src/trbSub.c | 615 ++++++++++++++++++ Trbnet/trbnetIoc/trbApp/src/trbSub.dbd | 23 + 63 files changed, 5345 insertions(+) create mode 100644 .cproject create mode 100644 .project create mode 100644 Trbnet/trbnetIoc/Makefile create mode 100644 Trbnet/trbnetIoc/configure/CONFIG create mode 100644 Trbnet/trbnetIoc/configure/CONFIG_SITE create mode 100644 Trbnet/trbnetIoc/configure/Makefile create mode 100644 Trbnet/trbnetIoc/configure/RELEASE create mode 100644 Trbnet/trbnetIoc/configure/RULES create mode 100644 Trbnet/trbnetIoc/configure/RULES.ioc create mode 100644 Trbnet/trbnetIoc/configure/RULES_DIRS create mode 100644 Trbnet/trbnetIoc/configure/RULES_TOP create mode 100644 Trbnet/trbnetIoc/iocBoot/Makefile create mode 100644 Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/Makefile create mode 100644 Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/README create mode 100644 Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/envPaths create mode 100644 Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/pid.txt create mode 100644 Trbnet/trbnetIoc/iocBoot/ioclxhadesdaq/st.cmd create mode 100644 Trbnet/trbnetIoc/trbApp/Db/Makefile create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsBeamstruct.db create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsMux.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegByte.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegByteScaled.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegC1.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegCombi.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegHiLo.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegNibble.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegNibbleScaled.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegRead.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegRead1.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegSimple.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegSimpleScaled.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsRegister.substitutions create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsScaler.substitutions create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsScalerRead.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/ctsScalerSingle.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/dbExample1.db create mode 100644 Trbnet/trbnetIoc/trbApp/Db/dbExample2.db create mode 100644 Trbnet/trbnetIoc/trbApp/Db/dbSubExample.db create mode 100644 Trbnet/trbnetIoc/trbApp/Db/oepRead.db create mode 100644 Trbnet/trbnetIoc/trbApp/Db/oepVolt.substitutions create mode 100644 Trbnet/trbnetIoc/trbApp/Db/oepVolt.template create mode 100644 Trbnet/trbnetIoc/trbApp/Db/trbExample.db create mode 100644 Trbnet/trbnetIoc/trbApp/Db/user.substitutions create mode 100644 Trbnet/trbnetIoc/trbApp/Db/userHost.substitutions create mode 100644 Trbnet/trbnetIoc/trbApp/Makefile create mode 100644 Trbnet/trbnetIoc/trbApp/src/Makefile create mode 100644 Trbnet/trbnetIoc/trbApp/src/dbSubExample.c create mode 100644 Trbnet/trbnetIoc/trbApp/src/dbSubExample.dbd create mode 100644 Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trberror.h create mode 100644 Trbnet/trbnetIoc/trbApp/src/extern/trbnet/include/trbnet.h create mode 100644 Trbnet/trbnetIoc/trbApp/src/extern/trbnet/lib/linux-x86/libtrbnet.a create mode 100644 Trbnet/trbnetIoc/trbApp/src/initTrace.c create mode 100644 Trbnet/trbnetIoc/trbApp/src/initTrace.dbd create mode 100644 Trbnet/trbnetIoc/trbApp/src/scalerN.c create mode 100644 Trbnet/trbnetIoc/trbApp/src/scaler_rat.c create mode 100644 Trbnet/trbnetIoc/trbApp/src/sncExample.dbd create mode 100644 Trbnet/trbnetIoc/trbApp/src/sncExample.stt create mode 100644 Trbnet/trbnetIoc/trbApp/src/sncProgram.st create mode 100644 Trbnet/trbnetIoc/trbApp/src/trbHello.c create mode 100644 Trbnet/trbnetIoc/trbApp/src/trbHello.dbd create mode 100644 Trbnet/trbnetIoc/trbApp/src/trbMain.cpp create mode 100644 Trbnet/trbnetIoc/trbApp/src/trbSub.c create mode 100644 Trbnet/trbnetIoc/trbApp/src/trbSub.dbd 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 0000000000000000000000000000000000000000..b1b9d4f503219122ff9322f4b97d7d4b2d526ae9 GIT binary patch literal 88830 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ÐtyvEB3Be&Zyy&ds0EJukQ4II~>S2_IP& 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 + +#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) -- 2.43.0