From 30bd8c66dc783d9792316e2333925083d895f6da Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Fri, 8 May 2026 14:45:25 +0200
Subject: [PATCH 1/8] presets all managed on epics side, separates presets from
 starting

---
 db/channels.db    |  48 ++++++++++++++++
 db/daq_2nd_gen.db |  81 +++++++++++++++++++++++++-
 db/daq_4ch.db     |  26 +++++++++
 db/daq_8ch.db     |  34 +++++++++++
 db/daq_common.db  | 142 +++++++++++++++++++++++++++++++++++++++++++---
 5 files changed, 321 insertions(+), 10 deletions(-)

diff --git a/db/channels.db b/db/channels.db
index 892d237..bf95320 100644
--- a/db/channels.db
+++ b/db/channels.db
@@ -26,6 +26,7 @@ record(seq, "$(INSTR)$(NAME):O$(CHANNEL)")
  field(DO0, 0)
  field(SELM, "Specified")
  field(SELL, "$(INSTR)$(NAME):M$(CHANNEL).VAL")
+ field(FLNK, "$(INSTR)$(NAME):MTS$(CHANNEL)")
 }
 
 # Current Status of Channel, i.e. is it ready to count?
@@ -37,6 +38,53 @@ record(bi, "$(INSTR)$(NAME):S$(CHANNEL)")
  field(ONAM, "CLEARING")
 }
 
+# If set, stop count once threshold reached
+record(int64in, "$(INSTR)$(NAME):MT$(CHANNEL)")
+{
+ field(DESC, "Monitor Count Threshold")
+ field(VAL, 0)
+ field(FLNK, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL)")
+}
+
+# Stop the count, if threshold is reached
+record(calcout, "$(INSTR)$(NAME):MTS$(CHANNEL)")
+{
+  field(INPA, "$(INSTR)$(NAME):M$(CHANNEL) NPP")
+  field(INPB, "$(INSTR)$(NAME):MT$(CHANNEL) NPP")
+  field(CALC, "B > 0 && A >= B")
+  field(OOPT, "When Non-zero")
+  field(OUT, "$(INSTR)$(NAME):STOP.PROC")
+}
+
+record(calcout, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL)")
+{
+ field(DESC, "Set to HW Mon Type if possible")
+ field(INPA, "$(INSTR)$(NAME):PRESET-TYPE NPP")
+ field(INPB, "$(INSTR)$(NAME):MT$(CHANNEL) NPP")
+ field(INPC, "$(INSTR)$(NAME):MONITOR-CHANNEL.DRVH NPP")
+ field(CALC, "A=0 && B>0 && $(CHANNEL)<=C")
+ field(OOPT, "When Non-zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "1")
+ field(OUT, "$(INSTR)$(NAME):SET-HW-CHANNEL$(CHANNEL).PROC")
+}
+
+# TODO, it might be necessary to wait for this to complete
+record(ao, "$(INSTR)$(NAME):SET-HW-CHANNEL$(CHANNEL)")
+{
+ field(OMSL, "closed_loop")
+ field(DOL,  $(CHANNEL))
+ field(OUT,  "$(INSTR)$(NAME):MONITOR-CHANNEL PP")
+ field(FLNK, "$(INSTR)$(NAME):SET-TYPE-MON2$(CHANNEL) PP")
+}
+
+record(ao, "$(INSTR)$(NAME):SET-TYPE-MON2$(CHANNEL)")
+{
+ field(OMSL, "closed_loop")
+ field(DOL,  2)
+ field(OUT,  "$(INSTR)$(NAME):PRESET-TYPE PP")
+}
+
 ################################################################################
 # Count Commands
 
diff --git a/db/daq_2nd_gen.db b/db/daq_2nd_gen.db
index 84c72e5..dafb9ce 100644
--- a/db/daq_2nd_gen.db
+++ b/db/daq_2nd_gen.db
@@ -20,12 +20,13 @@ record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
  field(FLNK, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV.PROC")
 }
 
+# TODO we might need to make sure we wait, when the channel is changed
 record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 {
  field(DESC, "PRESET-COUNT Monitors this channel")
  field(DTYP, "stream")
  field(INP, "@$(PROTO) readPresetMonitor($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(SCAN, "1 second")
+ field(SCAN, ".5 second")
  field(FLNK, "$(INSTR)$(NAME):CORRECT-MONITOR-CHANNEL.PROC")
 }
 
@@ -38,6 +39,84 @@ record(seq, "$(INSTR)$(NAME):CORRECT-MONITOR-CHANNEL")
  field(LNK0, "$(INSTR)$(NAME):MONITOR-CHANNEL PP")
 }
 
+record(sel, "$(INSTR)$(NAME):HW_MT")
+{
+ field(DESC, "Monitor threshold to actually use")
+ field(SELM, "Specified")
+ field(NVL,  "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV.VAL NPP")
+ # Skip A as it corresponds to 0
+ field(INPB, "$(INSTR)$(NAME):MT1 NPP")
+ field(INPC, "$(INSTR)$(NAME):MT2 NPP")
+ field(INPD, "$(INSTR)$(NAME):MT3 NPP")
+ field(INPE, "$(INSTR)$(NAME):MT4 NPP")
+ field(INPF, "$(INSTR)$(NAME):MT5 NPP")
+ field(INPG, "$(INSTR)$(NAME):MT6 NPP")
+ field(INPH, "$(INSTR)$(NAME):MT7 NPP")
+ field(INPI, "$(INSTR)$(NAME):MT8 NPP")
+ field(INPJ, "$(INSTR)$(NAME):MT9 NPP")
+ field(INPK, "$(INSTR)$(NAME):MT10 NPP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):RESET_HW_MT1 PP")
+ field(OUTB, "$(INSTR)$(NAME):RESET_HW_MT2 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT1")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):MT1 PP")
+ field(OUTB, "$(INSTR)$(NAME):MT2 PP")
+ field(OUTC, "$(INSTR)$(NAME):MT3 PP")
+ field(OUTD, "$(INSTR)$(NAME):MT4 PP")
+ field(OUTE, "$(INSTR)$(NAME):MT5 PP")
+ field(OUTF, "$(INSTR)$(NAME):MT6 PP")
+ field(OUTG, "$(INSTR)$(NAME):MT7 PP")
+ field(OUTH, "$(INSTR)$(NAME):MT8 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT2")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):MT9 PP")
+ field(OUTB, "$(INSTR)$(NAME):MT10 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):CMONITORS")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):CMONITORS1 PP")
+ field(OUTB, "$(INSTR)$(NAME):CMONITORS2 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):CMONITORS1")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):C1 PP")
+ field(OUTB, "$(INSTR)$(NAME):C2 PP")
+ field(OUTC, "$(INSTR)$(NAME):C3 PP")
+ field(OUTD, "$(INSTR)$(NAME):C4 PP")
+ field(OUTE, "$(INSTR)$(NAME):C5 PP")
+ field(OUTF, "$(INSTR)$(NAME):C6 PP")
+ field(OUTG, "$(INSTR)$(NAME):C7 PP")
+ field(OUTH, "$(INSTR)$(NAME):C8 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):CMONITORS2")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):C9 PP")
+ field(OUTB, "$(INSTR)$(NAME):C10 PP")
+}
+
 ################################################################################
 # Count Commands
 
diff --git a/db/daq_4ch.db b/db/daq_4ch.db
index ca34dd5..6a8713f 100644
--- a/db/daq_4ch.db
+++ b/db/daq_4ch.db
@@ -25,6 +25,32 @@ record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
  field(DISP, 1)
 }
 
+record(ai, "$(INSTR)$(NAME):HW_MT")
+{
+ field(DESC, "Monitor threshold to actually use")
+ field(INP,  "$(INSTR)$(NAME):MT1 NPP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
+{
+ field(OMSL, "supervisory")
+ field(SELM, "All")
+ field(OUTA, "$(INSTR)$(NAME):MT1 PP")
+ field(OUTB, "$(INSTR)$(NAME):MT2 PP")
+ field(OUTC, "$(INSTR)$(NAME):MT3 PP")
+ field(OUTD, "$(INSTR)$(NAME):MT4 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):CMONITORS")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):C1 PP")
+ field(OUTB, "$(INSTR)$(NAME):C2 PP")
+ field(OUTC, "$(INSTR)$(NAME):C3 PP")
+ field(OUTD, "$(INSTR)$(NAME):C4 PP")
+}
+
 ################################################################################
 # Count Commands
 
diff --git a/db/daq_8ch.db b/db/daq_8ch.db
index fa49da6..2a2ff47 100644
--- a/db/daq_8ch.db
+++ b/db/daq_8ch.db
@@ -25,6 +25,40 @@ record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
  field(DISP, 1)
 }
 
+record(ai, "$(INSTR)$(NAME):HW_MT")
+{
+ field(DESC, "Monitor threshold to actually use")
+ field(INP,  "$(INSTR)$(NAME):MT1 NPP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
+{
+ field(OMSL, "supervisory")
+ field(SELM, "All")
+ field(OUTA, "$(INSTR)$(NAME):MT1 PP")
+ field(OUTB, "$(INSTR)$(NAME):MT2 PP")
+ field(OUTC, "$(INSTR)$(NAME):MT3 PP")
+ field(OUTD, "$(INSTR)$(NAME):MT4 PP")
+ field(OUTE, "$(INSTR)$(NAME):MT5 PP")
+ field(OUTF, "$(INSTR)$(NAME):MT6 PP")
+ field(OUTG, "$(INSTR)$(NAME):MT7 PP")
+ field(OUTH, "$(INSTR)$(NAME):MT8 PP")
+}
+
+record(dfanout,"$(INSTR)$(NAME):CMONITORS")
+{
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ field(OUTA, "$(INSTR)$(NAME):C1 PP")
+ field(OUTB, "$(INSTR)$(NAME):C2 PP")
+ field(OUTC, "$(INSTR)$(NAME):C3 PP")
+ field(OUTD, "$(INSTR)$(NAME):C4 PP")
+ field(OUTE, "$(INSTR)$(NAME):C5 PP")
+ field(OUTF, "$(INSTR)$(NAME):C6 PP")
+ field(OUTG, "$(INSTR)$(NAME):C7 PP")
+ field(OUTH, "$(INSTR)$(NAME):C8 PP")
+}
+
 ################################################################################
 # Count Commands
 
diff --git a/db/daq_common.db b/db/daq_common.db
index f7b68af..c3aea46 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -107,6 +107,13 @@ record(bi, "$(INSTR)$(NAME):IS_PAUSED")
  field(ONAM, "PAUSED")
 }
 
+record(longin, "$(INSTR)$(NAME):COUNT_STARTED")
+{
+ field(DESC, "Internal Sent Start Count")
+ field(VAL,  0)
+ field(PINI, "YES")
+}
+
 record(calc, "$(INSTR)$(NAME):MAP-STATUS")
 {
  field(DESC, "Maps Raw Status to State")
@@ -116,7 +123,8 @@ record(calc, "$(INSTR)$(NAME):MAP-STATUS")
  field(INPD, "$(INSTR)$(NAME):COUNTING_PRESET PP MS")
  field(INPE, "$(INSTR)$(NAME):IS_LOWRATE PP MS")
  field(INPF, "$(INSTR)$(NAME):IS_PAUSED PP MS")
- field(CALC, "(A=1||B=1)?4:(F=1)?3:(C=0&&D=0)?0:(E=1)?2:1")
+ field(INPG, "$(INSTR)$(NAME):COUNT_STARTED NPP MS")
+ field(CALC, "(A=1||B=1)?4:(F=1)?3:(C=0&&D=0&&G<=0)?0:(E=1)?2:1")
  field(FLNK, "$(INSTR)$(NAME):STATUS")
 }
 
@@ -135,6 +143,52 @@ record(mbbi, "$(INSTR)$(NAME):STATUS")
  # 4 should never happen, if it does it means the DAQ reports undocumented statusbits
  field(FRVL, "4")
  field(FRST, "INVALID")
+ field(FLNK, "$(INSTR)$(NAME):RESET-P-PRESET")
+}
+
+record(calcout, "$(INSTR)$(NAME):RESET-P-PRESET")
+{
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP")
+ field(CALC, "A")
+ field(OOPT, "Transition To Zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "0")
+ field(OUT, "$(INSTR)$(NAME):PRESET-TYPE PP")
+ field(FLNK, "$(INSTR)$(NAME):RESET-HW_ETT")
+}
+
+record(calcout, "$(INSTR)$(NAME):RESET-HW_ETT")
+{
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP")
+ field(CALC, "A")
+ field(OOPT, "Transition To Zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "0")
+ field(OUT, "$(INSTR)$(NAME):HW_ETT PP")
+ field(FLNK, "$(INSTR)$(NAME):RESET-HW-PRESET")
+}
+
+record(calcout, "$(INSTR)$(NAME):RESET-HW-PRESET")
+{
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP")
+ field(CALC, "A")
+ field(OOPT, "Transition To Zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "0")
+ field(OUT, "$(INSTR)$(NAME):RESET_HW_MT PP")
+ field(FLNK, "$(INSTR)$(NAME):Z_COUNT_STARTED")
+}
+
+record(calcout, "$(INSTR)$(NAME):Z_COUNT_STARTED")
+{
+ field(INPA, "$(INSTR)$(NAME):COUNT_STARTED NPP")
+ field(INPB, "$(INSTR)$(NAME):COUNTING_TIME NPP MS")
+ field(INPC, "$(INSTR)$(NAME):COUNTING_PRESET NPP MS")
+ field(CALC, "A")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "(B||C)?0:A-1")
+ field(OOPT, "When Non-zero")
+ field(OUT, "$(INSTR)$(NAME):COUNT_STARTED PP")
 }
 
 record(longin, "$(INSTR)$(NAME):CHANNELS")
@@ -171,30 +225,100 @@ record(bi, "$(INSTR)$(NAME):ETS")
  field(ONAM, "CLEARING")
 }
 
+# Time Threshold
+record(int64in, "$(INSTR)$(NAME):HW_ETT")
+{
+ field(DESC, "Time Threshold")
+ field(VAL, 0)
+ field(FLNK, "$(INSTR)$(NAME):SET-TYPE-TIME")
+}
+
+record(calcout, "$(INSTR)$(NAME):SET-TYPE-TIME")
+{
+ field(INPA, "$(INSTR)$(NAME):PRESET-TYPE NPP")
+ field(INPB, "$(INSTR)$(NAME):HW_ETT NPP")
+ field(CALC, "A=0 && B>0")
+ field(OOPT, "When Non-zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "1")
+ field(OUT, "$(INSTR)$(NAME):PRESET-TYPE PP")
+}
+
 ################################################################################
 # Count Commands
 
-record(ao,"$(INSTR)$(NAME):PRESET-COUNT")
+record(mbbi, "$(INSTR)$(NAME):PRESET-TYPE")
 {
- field(DESC, "Count until preset reached")
- field(DTYP, "stream")
- field(OUT, "@$(PROTO) startWithCountPreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(VAL, 0)
- field(PREC, 2)
- field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
+ field(DESC, "Type of Hardware Preset")
+ field(ZRVL, "0")
+ field(ZRST, "Unset")
+ field(ONVL, "1")
+ field(ONST, "Time")
+ field(TWVL, "2")
+ field(TWST, "Monitor")
+ field(VAL,  0)
+ field(PINI, "YES")
+}
+
+record(bo,"$(INSTR)$(NAME):START")
+{
+ field(DESC, "Zero, then trigger")
+ field(FLNK, "$(INSTR)$(NAME):PREPARE")
+}
+
+record(dfanout,"$(INSTR)$(NAME):PREPARE")
+{
+ field(DESC, "Zero channels")
+ field(SELM, "All")
+ field(OMSL, "supervisory")
+ # Elapsed Time
+ field(OUTA, "$(INSTR)$(NAME):CT PP")
+ field(OUTB, "$(INSTR)$(NAME):CMONITORS PP")
+ field(FLNK, "$(INSTR)$(NAME):TRIGGER")
+}
+
+record(seq,"$(INSTR)$(NAME):TRIGGER")
+{
+ field(DESC, "Actually triggers sending start")
+ field(DO1, 1)
+ field(LNK1, "$(INSTR)$(NAME):PRESET-TIME.PROC")
+ field(DO2, 1)
+ field(LNK2, "$(INSTR)$(NAME):PRESET-COUNT.PROC")
+ field(SELM, "Specified")
+ field(SELL, "$(INSTR)$(NAME):PRESET-TYPE NPP")
+ field(FLNK, "$(INSTR)$(NAME):O_COUNT_STARTED")
+}
+
+record(longout, "$(INSTR)$(NAME):O_COUNT_STARTED")
+{
+ field(OMSL, "closed_loop")
+ field(DOL,  5)
+ field(OUT, "$(INSTR)$(NAME):COUNT_STARTED PP")
 }
 
 record(ao,"$(INSTR)$(NAME):PRESET-TIME")
 {
  field(DESC, "Count for specified time")
  field(DTYP, "stream")
+ field(OMSL, "closed_loop")
+ field(DOL,  "$(INSTR)$(NAME):HW_ETT NPP")
  field(OUT, "@$(PROTO) startWithTimePreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(VAL, 0)
  field(PREC, 2)
  field(EGU, "seconds")
  field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
 }
 
+record(ao,"$(INSTR)$(NAME):PRESET-COUNT")
+{
+ field(DESC, "Count until preset reached")
+ field(DTYP, "stream")
+ field(OMSL, "closed_loop")
+ field(DOL,  "$(INSTR)$(NAME):HW_MT PP")
+ field(OUT, "@$(PROTO) startWithCountPreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(PREC, 0)
+ field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
+}
+
 record(bo,"$(INSTR)$(NAME):PAUSE")
 {
  field(DESC, "Pause the current count")
-- 
2.52.0


From 6ecc3e8e86c15f2c86f344f1f14f0ff66cf9ec79 Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Fri, 8 May 2026 17:26:12 +0200
Subject: [PATCH 2/8] make status of channels busy for nicos...

---
 db/channels.db   | 19 ++++++++++++++-----
 db/daq_common.db | 17 +++++++++++++----
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/db/channels.db b/db/channels.db
index bf95320..c45c220 100644
--- a/db/channels.db
+++ b/db/channels.db
@@ -15,22 +15,21 @@ record(bo, "$(INSTR)$(NAME):T$(CHANNEL)")
 {
  field(DESC, "Trigger Clearing Status")
  field(VAL, 1)
- field(OUT, "$(INSTR)$(NAME):S$(CHANNEL) PP")
+ field(OUT, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED PP")
 }
 
 # Trigger a change in status as value returned to 0
 record(seq, "$(INSTR)$(NAME):O$(CHANNEL)")
 {
  field(DESC, "Trigger Returned to 0 Status")
- field(LNK0, "$(INSTR)$(NAME):S$(CHANNEL) PP")
  field(DO0, 0)
+ field(LNK0, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED PP")
  field(SELM, "Specified")
  field(SELL, "$(INSTR)$(NAME):M$(CHANNEL).VAL")
- field(FLNK, "$(INSTR)$(NAME):MTS$(CHANNEL)")
+ field(FLNK, "$(INSTR)$(NAME):S$(CHANNEL)")
 }
 
-# Current Status of Channel, i.e. is it ready to count?
-record(bi, "$(INSTR)$(NAME):S$(CHANNEL)")
+record(bi, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED")
 {
  field(DESC, "Channel Status")
  field(VAL, 0)
@@ -38,6 +37,16 @@ record(bi, "$(INSTR)$(NAME):S$(CHANNEL)")
  field(ONAM, "CLEARING")
 }
 
+# Current Status of Channel, i.e. is it ready to count?
+record(calc, "$(INSTR)$(NAME):S$(CHANNEL)")
+{
+ field(DESC, "Stupid Nicos Stuff")
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP")
+ field(INPB, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED NPP")
+ field(CALC, "A == 1 || B")
+ field(FLNK, "$(INSTR)$(NAME):MTS$(CHANNEL)")
+}
+
 # If set, stop count once threshold reached
 record(int64in, "$(INSTR)$(NAME):MT$(CHANNEL)")
 {
diff --git a/db/daq_common.db b/db/daq_common.db
index c3aea46..2c8f3e8 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -203,28 +203,37 @@ record(bo, "$(INSTR)$(NAME):ETT")
 {
  field(DESC, "Trigger Clearing Status")
  field(VAL, 1)
- field(OUT, "$(INSTR)$(NAME):ETS PP")
+ field(OUT, "$(INSTR)$(NAME):ET_CLEARED PP")
 }
 
 # Trigger a change in status as value returned to 0
 record(seq, "$(INSTR)$(NAME):ETO")
 {
  field(DESC, "Trigger Returned to 0 Status")
- field(LNK0, "$(INSTR)$(NAME):ETS PP")
+ field(LNK0, "$(INSTR)$(NAME):ET_CLEARED PP")
  field(DO0, 0)
  field(SELM, "Specified")
  field(SELL, "$(INSTR)$(NAME):ELAPSED-TIME.VAL")
+ field(FLNK, "$(INSTR)$(NAME):ETS")
 }
 
 # Current Status of Channel, i.e. is it ready to count?
-record(bi, "$(INSTR)$(NAME):ETS")
+record(bi, "$(INSTR)$(NAME):ET_CLEARED")
 {
  field(DESC, "Channel Status")
  field(VAL, 0)
- field(ZNAM, "OK")
+ field(ZNAM, "CLEARED")
  field(ONAM, "CLEARING")
 }
 
+record(calc, "$(INSTR)$(NAME):ETS")
+{
+ field(DESC, "Stupid Nicos Stuff")
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP")
+ field(INPB, "$(INSTR)$(NAME):ET_CLEARED NPP")
+ field(CALC, "A == 1 || B")
+}
+
 # Time Threshold
 record(int64in, "$(INSTR)$(NAME):HW_ETT")
 {
-- 
2.52.0


From a413fecc4399a0312aab40f527485857cd604ca4 Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Mon, 11 May 2026 10:41:04 +0200
Subject: [PATCH 3/8] adds software time preset, improves preset monitor
 switching logic

---
 db/channels.db    | 53 +++++++++++++++++++++++++++++++++++++++++++----
 db/daq_2nd_gen.db | 31 +++++++++++++++++++++++++++
 db/daq_4ch.db     | 10 +++++++++
 db/daq_8ch.db     | 14 +++++++++++++
 db/daq_common.db  | 29 ++++++++++++++++++++++++++
 5 files changed, 133 insertions(+), 4 deletions(-)

diff --git a/db/channels.db b/db/channels.db
index c45c220..8c2971f 100644
--- a/db/channels.db
+++ b/db/channels.db
@@ -10,6 +10,15 @@
 ################################################################################
 # Status Variables
 
+# record(dfanout, "$(INSTR)$(NAME):RESET_MT$(CHANNEL)")
+# {
+#  field(DESC, "Resets Internal Variables")
+#  field(SELM, "All")
+#  field(OMSL, "supervisory")
+#  field(OUTA, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED PP")
+#  field(OUTB, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET PP")
+# }
+
 # Trigger a change in status as clearing
 record(bo, "$(INSTR)$(NAME):T$(CHANNEL)")
 {
@@ -37,13 +46,14 @@ record(bi, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED")
  field(ONAM, "CLEARING")
 }
 
-# Current Status of Channel, i.e. is it ready to count?
+# Current Status of Channel, i.e. is it ready for a new operation?
 record(calc, "$(INSTR)$(NAME):S$(CHANNEL)")
 {
  field(DESC, "Stupid Nicos Stuff")
  field(INPA, "$(INSTR)$(NAME):STATUS NPP")
  field(INPB, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED NPP")
- field(CALC, "A == 1 || B")
+ field(INPC, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET NPP")
+ field(CALC, "A == 1 || B || C")
  field(FLNK, "$(INSTR)$(NAME):MTS$(CHANNEL)")
 }
 
@@ -52,7 +62,7 @@ record(int64in, "$(INSTR)$(NAME):MT$(CHANNEL)")
 {
  field(DESC, "Monitor Count Threshold")
  field(VAL, 0)
- field(FLNK, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL)")
+ field(FLNK, "$(INSTR)$(NAME):M$(CHANNEL)_SET")
 }
 
 # Stop the count, if threshold is reached
@@ -65,6 +75,42 @@ record(calcout, "$(INSTR)$(NAME):MTS$(CHANNEL)")
   field(OUT, "$(INSTR)$(NAME):STOP.PROC")
 }
 
+record(dfanout, "$(INSTR)$(NAME):M$(CHANNEL)_SET")
+{
+ field(DESC, "Trigger setting HW preset")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET PP")
+ field(OUTB, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL).PROC PP")
+}
+
+record(calcout, "$(INSTR)$(NAME):M$(CHANNEL)_CHECK_SET")
+{
+ field(SCAN, ".1 second")
+ field(INPA, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET NPP")
+ field(INPB, "$(INSTR)$(NAME):MONITOR-CHANNEL NPP")
+ field(INPC, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV NPP")
+ field(CALC, "A && ( ($(CHANNEL) # B) || (B = C) )")
+ field(OOPT, "When Non-zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "0")
+ # This is just a delay, as otherwise, Nicos will not see
+ # the $(INSTR)$(NAME):M$(CHANNEL)_PRESET state change
+ # when not changing which monitor channel the preset
+ # applies to. Is there a better way?
+ field(ODLY, .5)
+ field(OUT,  "$(INSTR)$(NAME):M$(CHANNEL)_PRESET PP")
+}
+
+record(bi, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET")
+{
+ field(DESC, "Channel Status")
+ field(VAL, 0)
+ field(ZNAM, "OK")
+ field(ONAM, "SETTING")
+}
+
 record(calcout, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL)")
 {
  field(DESC, "Set to HW Mon Type if possible")
@@ -78,7 +124,6 @@ record(calcout, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL)")
  field(OUT, "$(INSTR)$(NAME):SET-HW-CHANNEL$(CHANNEL).PROC")
 }
 
-# TODO, it might be necessary to wait for this to complete
 record(ao, "$(INSTR)$(NAME):SET-HW-CHANNEL$(CHANNEL)")
 {
  field(OMSL, "closed_loop")
diff --git a/db/daq_2nd_gen.db b/db/daq_2nd_gen.db
index dafb9ce..dbed757 100644
--- a/db/daq_2nd_gen.db
+++ b/db/daq_2nd_gen.db
@@ -87,6 +87,37 @@ record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT2")
  field(OUTB, "$(INSTR)$(NAME):MT10 PP")
 }
 
+# record(dfanout,"$(INSTR)$(NAME):RESET_MT")
+# {
+#  field(DESC, "Resets Internal Variables")
+#  field(SELM, "All")
+#  field(OMSL, "supervisory")
+#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
+#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
+# }
+#
+# record(dfanout,"$(INSTR)$(NAME):RESET_MT1")
+# {
+#  field(SELM, "All")
+#  field(OMSL, "supervisory")
+#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
+#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
+#  field(OUTC, "$(INSTR)$(NAME):RESET_MT3 PP")
+#  field(OUTD, "$(INSTR)$(NAME):RESET_MT4 PP")
+#  field(OUTE, "$(INSTR)$(NAME):RESET_MT5 PP")
+#  field(OUTF, "$(INSTR)$(NAME):RESET_MT6 PP")
+#  field(OUTG, "$(INSTR)$(NAME):RESET_MT7 PP")
+#  field(OUTH, "$(INSTR)$(NAME):RESET_MT8 PP")
+# }
+#
+# record(dfanout,"$(INSTR)$(NAME):RESET_MT2")
+# {
+#  field(SELM, "All")
+#  field(OMSL, "supervisory")
+#  field(OUTA, "$(INSTR)$(NAME):RESET_MT9 PP")
+#  field(OUTB, "$(INSTR)$(NAME):RESET_MT10 PP")
+# }
+
 record(dfanout,"$(INSTR)$(NAME):CMONITORS")
 {
  field(SELM, "All")
diff --git a/db/daq_4ch.db b/db/daq_4ch.db
index 6a8713f..81a3bf8 100644
--- a/db/daq_4ch.db
+++ b/db/daq_4ch.db
@@ -41,6 +41,16 @@ record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
  field(OUTD, "$(INSTR)$(NAME):MT4 PP")
 }
 
+# record(dfanout,"$(INSTR)$(NAME):RESET_MT")
+# {
+#  field(OMSL, "supervisory")
+#  field(SELM, "All")
+#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
+#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
+#  field(OUTC, "$(INSTR)$(NAME):RESET_MT3 PP")
+#  field(OUTD, "$(INSTR)$(NAME):RESET_MT4 PP")
+# }
+
 record(dfanout,"$(INSTR)$(NAME):CMONITORS")
 {
  field(SELM, "All")
diff --git a/db/daq_8ch.db b/db/daq_8ch.db
index 2a2ff47..ece1e16 100644
--- a/db/daq_8ch.db
+++ b/db/daq_8ch.db
@@ -45,6 +45,20 @@ record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
  field(OUTH, "$(INSTR)$(NAME):MT8 PP")
 }
 
+# record(dfanout,"$(INSTR)$(NAME):RESET_MT")
+# {
+#  field(OMSL, "supervisory")
+#  field(SELM, "All")
+#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
+#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
+#  field(OUTC, "$(INSTR)$(NAME):RESET_MT3 PP")
+#  field(OUTD, "$(INSTR)$(NAME):RESET_MT4 PP")
+#  field(OUTE, "$(INSTR)$(NAME):RESET_MT5 PP")
+#  field(OUTF, "$(INSTR)$(NAME):RESET_MT6 PP")
+#  field(OUTG, "$(INSTR)$(NAME):RESET_MT7 PP")
+#  field(OUTH, "$(INSTR)$(NAME):RESET_MT8 PP")
+# }
+
 record(dfanout,"$(INSTR)$(NAME):CMONITORS")
 {
  field(SELM, "All")
diff --git a/db/daq_common.db b/db/daq_common.db
index 2c8f3e8..1a75c10 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -22,6 +22,24 @@ record(longout, "$(INSTR)$(NAME):FULL-RESET")
  field(DTYP, "stream")
 }
 
+record(dfanout, "$(INSTR)$(NAME):RESET")
+{
+ field(DESC, "Reset internal state")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  "0")
+ # Internal Count Timer
+ field(OUTA, "$(INSTR)$(NAME):COUNT_STARTED PP")
+ # Time Preset
+ # field(OUTB, "$(INSTR)$(NAME):HW_ETT PP")
+ # field(OUTC, "$(INSTR)$(NAME):ET_CLEARED PP")
+ # Monitor Presets
+ # field(OUTD, "$(INSTR)$(NAME):RESET_HW_MT PP")
+ # field(OUTE, "$(INSTR)$(NAME):RESET_MT PP")
+ # HW Preset Type
+ # field(OUTF, "$(INSTR)$(NAME):PRESET-TYPE PP")
+}
+
 ################################################################################
 # Status Variables
 
@@ -232,6 +250,7 @@ record(calc, "$(INSTR)$(NAME):ETS")
  field(INPA, "$(INSTR)$(NAME):STATUS NPP")
  field(INPB, "$(INSTR)$(NAME):ET_CLEARED NPP")
  field(CALC, "A == 1 || B")
+ field(FLNK, "$(INSTR)$(NAME):ETCHECK")
 }
 
 # Time Threshold
@@ -242,6 +261,16 @@ record(int64in, "$(INSTR)$(NAME):HW_ETT")
  field(FLNK, "$(INSTR)$(NAME):SET-TYPE-TIME")
 }
 
+# Stop the count, if threshold is reached
+record(calcout, "$(INSTR)$(NAME):ETCHECK")
+{
+  field(INPA, "$(INSTR)$(NAME):ELAPSED-TIME NPP")
+  field(INPB, "$(INSTR)$(NAME):HW_ETT NPP")
+  field(CALC, "B > 0 && A >= B")
+  field(OOPT, "When Non-zero")
+  field(OUT, "$(INSTR)$(NAME):STOP.PROC")
+}
+
 record(calcout, "$(INSTR)$(NAME):SET-TYPE-TIME")
 {
  field(INPA, "$(INSTR)$(NAME):PRESET-TYPE NPP")
-- 
2.52.0


From b7a106eae3f3aef82585734485f73e24c087b115 Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Tue, 26 May 2026 14:57:11 +0200
Subject: [PATCH 4/8] if no valid in hardware preset, start box with a time
 based count, and check in software

---
 db/daq_common.db | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/db/daq_common.db b/db/daq_common.db
index 1a75c10..554465d 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -318,6 +318,8 @@ record(dfanout,"$(INSTR)$(NAME):PREPARE")
 record(seq,"$(INSTR)$(NAME):TRIGGER")
 {
  field(DESC, "Actually triggers sending start")
+ field(DO0, 1)
+ field(LNK0, "$(INSTR)$(NAME):FAKE-HW-COUNT.PROC")
  field(DO1, 1)
  field(LNK1, "$(INSTR)$(NAME):PRESET-TIME.PROC")
  field(DO2, 1)
@@ -334,6 +336,15 @@ record(longout, "$(INSTR)$(NAME):O_COUNT_STARTED")
  field(OUT, "$(INSTR)$(NAME):COUNT_STARTED PP")
 }
 
+record(ao, "$(INSTR)$(NAME):FAKE-HW-COUNT")
+{
+ field(DESC, "Count forever :)")
+ field(OMSL, "closed_loop")
+ field(DOL,  "15768000") # Half a year
+ field(OUT, "$(INSTR)$(NAME):HW_ETT")
+ field(FLNK, "$(INSTR)$(NAME):PRESET-TIME")
+}
+
 record(ao,"$(INSTR)$(NAME):PRESET-TIME")
 {
  field(DESC, "Count for specified time")
-- 
2.52.0


From 0789462aed29e34decb98912d6593fcc49ee8c47 Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Wed, 3 Jun 2026 16:49:47 +0200
Subject: [PATCH 5/8] rename/refactor channels.db

---
 db/channels.db    | 262 +++++++++++++++++++++++++---------------------
 db/daq_2nd_gen.db |  93 ++++++++--------
 db/daq_4ch.db     |  36 +++----
 db/daq_8ch.db     |  64 +++++------
 db/daq_common.db  |   7 +-
 5 files changed, 234 insertions(+), 228 deletions(-)

diff --git a/db/channels.db b/db/channels.db
index 8c2971f..72469e6 100644
--- a/db/channels.db
+++ b/db/channels.db
@@ -8,87 +8,151 @@
 # CHANNEL - the number associated with the measurment channel
 
 ################################################################################
-# Status Variables
+# Channel Specific
 
-# record(dfanout, "$(INSTR)$(NAME):RESET_MT$(CHANNEL)")
-# {
-#  field(DESC, "Resets Internal Variables")
-#  field(SELM, "All")
-#  field(OMSL, "supervisory")
-#  field(OUTA, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED PP")
-#  field(OUTB, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET PP")
-# }
-
-# Trigger a change in status as clearing
-record(bo, "$(INSTR)$(NAME):T$(CHANNEL)")
+# Updated by READALL, at POLL_FREQ frequency
+record(int64in, "$(INSTR)$(NAME):CH$(CHANNEL)")
 {
- field(DESC, "Trigger Clearing Status")
- field(VAL, 1)
- field(OUT, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED PP")
+ field(DESC, "DAQ CH$(CHANNEL) Counts")
+ field(EGU,  "cts")
+ field(FLNK, "$(INSTR)$(NAME):CH$(CHANNEL)_POLL")
 }
 
-# Trigger a change in status as value returned to 0
-record(seq, "$(INSTR)$(NAME):O$(CHANNEL)")
+record(ai, "$(INSTR)$(NAME):CH$(CHANNEL)_RATE")
 {
- field(DESC, "Trigger Returned to 0 Status")
- field(DO0, 0)
- field(LNK0, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED PP")
- field(SELM, "Specified")
- field(SELL, "$(INSTR)$(NAME):M$(CHANNEL).VAL")
- field(FLNK, "$(INSTR)$(NAME):S$(CHANNEL)")
+ field(DESC, "Rate of DAQ CH$(CHANNEL)")
+ field(INP,  "@$(PROTO) readRate($(INSTR)$(NAME):, $(CHANNEL)) $(ASYN_PORT)")
+ field(DTYP, "stream")
+ field(EGU, "cts/sec")
+ field(SCAN, "1 second")
 }
 
-record(bi, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED")
+record(ao, "$(INSTR)$(NAME):CH$(CHANNEL)_THRESH")
 {
- field(DESC, "Channel Status")
- field(VAL, 0)
- field(ZNAM, "OK")
- field(ONAM, "CLEARING")
+ # Rate for this channel only applies, if
+ # $(INSTR)$(NAME):THRESHOLD-MONITOR == $(CHANNEL)
+ field(DESC, "Sets min rate for counting to proceed")
+ field(OMSL, "supervisory")
+ field(OROC, "0")
+ field(OUT,  "@$(PROTO) setMinRate($(INSTR)$(NAME):, $(CHANNEL)) $(ASYN_PORT)")
+ field(DTYP, "stream")
+ field(EGU,  "cts/sec")
 }
 
-# Current Status of Channel, i.e. is it ready for a new operation?
-record(calc, "$(INSTR)$(NAME):S$(CHANNEL)")
-{
- field(DESC, "Stupid Nicos Stuff")
- field(INPA, "$(INSTR)$(NAME):STATUS NPP")
- field(INPB, "$(INSTR)$(NAME):M$(CHANNEL)_CLEARED NPP")
- field(INPC, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET NPP")
- field(CALC, "A == 1 || B || C")
- field(FLNK, "$(INSTR)$(NAME):MTS$(CHANNEL)")
-}
+################################################################################
+# Poll Loop
 
-# If set, stop count once threshold reached
-record(int64in, "$(INSTR)$(NAME):MT$(CHANNEL)")
+record(dfanout, "$(INSTR)$(NAME):CH$(CHANNEL)_POLL")
 {
- field(DESC, "Monitor Count Threshold")
- field(VAL, 0)
- field(FLNK, "$(INSTR)$(NAME):M$(CHANNEL)_SET")
-}
-
-# Stop the count, if threshold is reached
-record(calcout, "$(INSTR)$(NAME):MTS$(CHANNEL)")
-{
-  field(INPA, "$(INSTR)$(NAME):M$(CHANNEL) NPP")
-  field(INPB, "$(INSTR)$(NAME):MT$(CHANNEL) NPP")
-  field(CALC, "B > 0 && A >= B")
-  field(OOPT, "When Non-zero")
-  field(OUT, "$(INSTR)$(NAME):STOP.PROC")
-}
-
-record(dfanout, "$(INSTR)$(NAME):M$(CHANNEL)_SET")
-{
- field(DESC, "Trigger setting HW preset")
+ field(DESC, "Channel $(CHANNEL) poll sequence")
  field(SELM, "All")
  field(OMSL, "closed_loop")
  field(DOL,  1)
- field(OUTA, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET PP")
- field(OUTB, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL).PROC PP")
+ field(OUTA, "$(INSTR)$(NAME):CH$(CHANNEL)_HWCS.PROC")
+ field(OUTB, "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW.PROC")
+ field(OUTC, "$(INSTR)$(NAME):CH$(CHANNEL)_REACHED.PROC")
 }
 
-record(calcout, "$(INSTR)$(NAME):M$(CHANNEL)_CHECK_SET")
+################################################################################
+# Clearing Channel Counts
+
+record(bi, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED")
 {
+ field(VAL,  0)
+ field(ZNAM, "Cleared")
+ field(ONAM, "Clearing")
+}
+
+# Trigger a change in status as value returned to 0
+record(seq, "$(INSTR)$(NAME):CH$(CHANNEL)_HWCS")
+{
+ field(DESC, "Trigger Returned to 0 Status")
+ field(SELM, "Specified")
+ field(SELL, "$(INSTR)$(NAME):CH$(CHANNEL).VAL")
+ field(DO0,  0)
+ field(LNK0, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED PP")
+}
+
+record(dfanout, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEAR")
+{
+ field(DESC, "Clears the current channel count")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED PP PP")
+ field(OUTB, "$(INSTR)$(NAME):CH$(CHANNEL)_HWC.PROC PP")
+}
+
+record(longout, "$(INSTR)$(NAME):CH$(CHANNEL)_HWC")
+{
+ field(DESC, "Clear in Hardware")
+ field(DTYP, "stream")
+ field(OMSL, "closed_loop")
+ field(DOL,  "$(INSTR)$(NAME):CH$(CHANNEL)_BM NPP")
+ field(OUT,  "@$(PROTO) clearChannel($(INSTR)$(NAME):) $(ASYN_PORT)")
+}
+
+################################################################################
+# Determining Channel Status
+
+record(calc, "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW")
+{
+ field(DESC, "Channel Status")
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP")
+ field(INPB, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED NPP")
+ field(INPC, "$(INSTR)$(NAME):CH$(CHANNEL)_SET NPP")
+ field(CALC, "A == 1 || B || C")
+ field(FLNK, "$(INSTR)$(NAME):CH$(CHANNEL)_STS")
+}
+
+# Current Status of Channel, i.e. is it ready for a new operation?
+record(mbbi, "$(INSTR)$(NAME):CH$(CHANNEL)_STS")
+{
+ field(DESC, "Channel Status")
+ field(INP,  "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW NPP MS")
+ field(ZRVL, "0")
+ field(ZRST, "Idle")
+ field(ONVL, "1")
+ field(ONST, "Busy")
+}
+
+################################################################################
+# Channel Preset
+
+# If set, stop count once preset reached
+record(int64in, "$(INSTR)$(NAME):CH$(CHANNEL)_PRESET")
+{
+ field(DESC, "Monitor Count Preset")
+ field(VAL,  0)
+ field(FLNK, "$(INSTR)$(NAME):CH$(CHANNEL)_SETTING")
+}
+
+record(calcout, "$(INSTR)$(NAME):CH$(CHANNEL)_REACHED")
+{
+ field(DESC, "Stop if preset reached")
+ field(INPA, "$(INSTR)$(NAME):CH$(CHANNEL) NPP")
+ field(INPB, "$(INSTR)$(NAME):CH$(CHANNEL)_PRESET NPP")
+ field(CALC, "B > 0 && A >= B")
+ field(OOPT, "When Non-zero")
+ field(OUT,  "$(INSTR)$(NAME):STOP.PROC")
+}
+
+################################################################################
+# Setting Channel Preset
+
+record(bi, "$(INSTR)$(NAME):CH$(CHANNEL)_SET")
+{
+ field(DESC, "Channel Status")
+ field(VAL,  0)
+ field(ZNAM, "Set")
+ field(ONAM, "Setting")
+}
+
+record(calcout, "$(INSTR)$(NAME):CH$(CHANNEL)_CHECK_SET")
+{
+ field(DESC, "Was preset fully configured")
  field(SCAN, ".1 second")
- field(INPA, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET NPP")
+ field(INPA, "$(INSTR)$(NAME):CH$(CHANNEL)_SET NPP")
  field(INPB, "$(INSTR)$(NAME):MONITOR-CHANNEL NPP")
  field(INPC, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV NPP")
  field(CALC, "A && ( ($(CHANNEL) # B) || (B = C) )")
@@ -96,43 +160,46 @@ record(calcout, "$(INSTR)$(NAME):M$(CHANNEL)_CHECK_SET")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
  # This is just a delay, as otherwise, Nicos will not see
- # the $(INSTR)$(NAME):M$(CHANNEL)_PRESET state change
+ # the $(INSTR)$(NAME):CH$(CHANNEL)_SET state change
  # when not changing which monitor channel the preset
  # applies to. Is there a better way?
  field(ODLY, .5)
- field(OUT,  "$(INSTR)$(NAME):M$(CHANNEL)_PRESET PP")
+ field(OUT,  "$(INSTR)$(NAME):CH$(CHANNEL)_SET PP")
 }
 
-record(bi, "$(INSTR)$(NAME):M$(CHANNEL)_PRESET")
+record(dfanout, "$(INSTR)$(NAME):CH$(CHANNEL)_SETTING")
 {
- field(DESC, "Channel Status")
- field(VAL, 0)
- field(ZNAM, "OK")
- field(ONAM, "SETTING")
+ field(DESC, "Trigger setting HW preset")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH$(CHANNEL)_SET PP")
+ field(OUTB, "$(INSTR)$(NAME):CH$(CHANNEL)_IN_HW.PROC PP")
 }
 
-record(calcout, "$(INSTR)$(NAME):SET-TYPE-MON$(CHANNEL)")
+record(calcout, "$(INSTR)$(NAME):CH$(CHANNEL)_IN_HW")
 {
- field(DESC, "Set to HW Mon Type if possible")
+ field(DESC, "Possible to configure in HW")
  field(INPA, "$(INSTR)$(NAME):PRESET-TYPE NPP")
- field(INPB, "$(INSTR)$(NAME):MT$(CHANNEL) NPP")
+ field(INPB, "$(INSTR)$(NAME):CH$(CHANNEL)_PRESET NPP")
  field(INPC, "$(INSTR)$(NAME):MONITOR-CHANNEL.DRVH NPP")
  field(CALC, "A=0 && B>0 && $(CHANNEL)<=C")
  field(OOPT, "When Non-zero")
  field(DOPT, "Use OCAL")
  field(OCAL, "1")
- field(OUT, "$(INSTR)$(NAME):SET-HW-CHANNEL$(CHANNEL).PROC")
+ field(OUT, "$(INSTR)$(NAME):CH$(CHANNEL)_HW_CONF.PROC")
 }
 
-record(ao, "$(INSTR)$(NAME):SET-HW-CHANNEL$(CHANNEL)")
+record(ao, "$(INSTR)$(NAME):CH$(CHANNEL)_HW_CONF")
 {
+ field(DESC, "Configure in HW")
  field(OMSL, "closed_loop")
  field(DOL,  $(CHANNEL))
  field(OUT,  "$(INSTR)$(NAME):MONITOR-CHANNEL PP")
- field(FLNK, "$(INSTR)$(NAME):SET-TYPE-MON2$(CHANNEL) PP")
+ field(FLNK, "$(INSTR)$(NAME):CH$(CHANNEL)_SET_PTYPE PP")
 }
 
-record(ao, "$(INSTR)$(NAME):SET-TYPE-MON2$(CHANNEL)")
+record(ao, "$(INSTR)$(NAME):CH$(CHANNEL)_SET_PTYPE")
 {
  field(OMSL, "closed_loop")
  field(DOL,  2)
@@ -140,8 +207,6 @@ record(ao, "$(INSTR)$(NAME):SET-TYPE-MON2$(CHANNEL)")
 }
 
 ################################################################################
-# Count Commands
-
 # Unfortunately, clearing the channels is somewhat complicated as a result of
 # the addition of more channels over time and minimal changes to the underlying interface
 #
@@ -165,49 +230,10 @@ record(ao, "$(INSTR)$(NAME):SET-TYPE-MON2$(CHANNEL)")
 # CC 5 setzt gleichzeitig die Zähler der Channels 1 und 3 zurück
 # CC 16 ist gleichbedeutend wie CT (Timer zurücksetzen)
 # CC 511 setzt gleichzeitig die Zähler aller Kanäle (auch des Timers) zurück.
-
-record(calc, "$(INSTR)$(NAME):BM$(CHANNEL)")
+record(calc, "$(INSTR)$(NAME):CH$(CHANNEL)_BM")
 {
  field(DESC, "Bit Mask for Channel")
  field(INPA, $(CHANNEL))
  field(CALC, "A > 4 ? 2 ^ A : 2 ^ (A-1)")
  field(PINI, "YES")
 }
-
-record(longout, "$(INSTR)$(NAME):C$(CHANNEL)")
-{
- field(DESC, "Clear the current channel count")
- field(DTYP, "stream")
- field(OMSL, "closed_loop")
- field(DOL, "$(INSTR)$(NAME):BM$(CHANNEL) NPP")
- field(OUT, "@$(PROTO) clearChannel($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(FLNK, "$(INSTR)$(NAME):T$(CHANNEL)")
-}
-
-record(ao,"$(INSTR)$(NAME):THRESH$(CHANNEL)")
-{
- field(DESC, "Sets min rate for counting to proceed")
- field(OMSL, "supervisory")
- field(OROC, "0")
- field(OUT, "@$(PROTO) setMinRate($(INSTR)$(NAME):, $(CHANNEL)) $(ASYN_PORT)")
- field(DTYP, "stream")
-}
-
-################################################################################
-# Read all monitors values
-
-record(int64in, "$(INSTR)$(NAME):M$(CHANNEL)")
-{
- field(DESC, "DAQ CH$(CHANNEL)")
- field(EGU, "cts")
- field(FLNK, "$(INSTR)$(NAME):O$(CHANNEL)")
-}
-
-record(ai, "$(INSTR)$(NAME):R$(CHANNEL)")
-{
- field(DESC, "Rate of DAQ CH$(CHANNEL)")
- field(INP, "@$(PROTO) readRate($(INSTR)$(NAME):, $(CHANNEL)) $(ASYN_PORT)")
- field(DTYP, "stream")
- field(EGU, "cts/sec")
- field(SCAN, "1 second")
-}
diff --git a/db/daq_2nd_gen.db b/db/daq_2nd_gen.db
index dbed757..512e303 100644
--- a/db/daq_2nd_gen.db
+++ b/db/daq_2nd_gen.db
@@ -45,46 +45,49 @@ record(sel, "$(INSTR)$(NAME):HW_MT")
  field(SELM, "Specified")
  field(NVL,  "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV.VAL NPP")
  # Skip A as it corresponds to 0
- field(INPB, "$(INSTR)$(NAME):MT1 NPP")
- field(INPC, "$(INSTR)$(NAME):MT2 NPP")
- field(INPD, "$(INSTR)$(NAME):MT3 NPP")
- field(INPE, "$(INSTR)$(NAME):MT4 NPP")
- field(INPF, "$(INSTR)$(NAME):MT5 NPP")
- field(INPG, "$(INSTR)$(NAME):MT6 NPP")
- field(INPH, "$(INSTR)$(NAME):MT7 NPP")
- field(INPI, "$(INSTR)$(NAME):MT8 NPP")
- field(INPJ, "$(INSTR)$(NAME):MT9 NPP")
- field(INPK, "$(INSTR)$(NAME):MT10 NPP")
+ field(INPB, "$(INSTR)$(NAME):CH1_PRESET NPP")
+ field(INPC, "$(INSTR)$(NAME):CH2_PRESET NPP")
+ field(INPD, "$(INSTR)$(NAME):CH3_PRESET NPP")
+ field(INPE, "$(INSTR)$(NAME):CH4_PRESET NPP")
+ field(INPF, "$(INSTR)$(NAME):CH5_PRESET NPP")
+ field(INPG, "$(INSTR)$(NAME):CH6_PRESET NPP")
+ field(INPH, "$(INSTR)$(NAME):CH7_PRESET NPP")
+ field(INPI, "$(INSTR)$(NAME):CH8_PRESET NPP")
+ field(INPJ, "$(INSTR)$(NAME):CH9_PRESET NPP")
+ field(INPK, "$(INSTR)$(NAME):CH10_PRESET NPP")
 }
 
 record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
 {
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):RESET_HW_MT1 PP")
- field(OUTB, "$(INSTR)$(NAME):RESET_HW_MT2 PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):RESET_HW_MT1.PROC")
+ field(OUTB, "$(INSTR)$(NAME):RESET_HW_MT2.PROC")
 }
 
 record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT1")
 {
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):MT1 PP")
- field(OUTB, "$(INSTR)$(NAME):MT2 PP")
- field(OUTC, "$(INSTR)$(NAME):MT3 PP")
- field(OUTD, "$(INSTR)$(NAME):MT4 PP")
- field(OUTE, "$(INSTR)$(NAME):MT5 PP")
- field(OUTF, "$(INSTR)$(NAME):MT6 PP")
- field(OUTG, "$(INSTR)$(NAME):MT7 PP")
- field(OUTH, "$(INSTR)$(NAME):MT8 PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  0)
+ field(OUTA, "$(INSTR)$(NAME):CH1_PRESET PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_PRESET PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_PRESET PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_PRESET PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_PRESET PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_PRESET PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_PRESET PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_PRESET PP")
 }
 
 record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT2")
 {
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):MT9 PP")
- field(OUTB, "$(INSTR)$(NAME):MT10 PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  0)
+ field(OUTA, "$(INSTR)$(NAME):CH9_PRESET PP")
+ field(OUTB, "$(INSTR)$(NAME):CH10_PRESET PP")
 }
 
 # record(dfanout,"$(INSTR)$(NAME):RESET_MT")
@@ -130,22 +133,22 @@ record(dfanout,"$(INSTR)$(NAME):CMONITORS1")
 {
  field(SELM, "All")
  field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):C1 PP")
- field(OUTB, "$(INSTR)$(NAME):C2 PP")
- field(OUTC, "$(INSTR)$(NAME):C3 PP")
- field(OUTD, "$(INSTR)$(NAME):C4 PP")
- field(OUTE, "$(INSTR)$(NAME):C5 PP")
- field(OUTF, "$(INSTR)$(NAME):C6 PP")
- field(OUTG, "$(INSTR)$(NAME):C7 PP")
- field(OUTH, "$(INSTR)$(NAME):C8 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_CLEAR PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_CLEAR PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_CLEAR PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_CLEAR PP")
 }
 
 record(dfanout,"$(INSTR)$(NAME):CMONITORS2")
 {
  field(SELM, "All")
  field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):C9 PP")
- field(OUTB, "$(INSTR)$(NAME):C10 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH9_CLEAR PP")
+ field(OUTB, "$(INSTR)$(NAME):CH10_CLEAR PP")
 }
 
 ################################################################################
@@ -166,22 +169,22 @@ record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F1")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):THRESH1 PP")
- field(OUTB, "$(INSTR)$(NAME):THRESH2 PP")
- field(OUTC, "$(INSTR)$(NAME):THRESH3 PP")
- field(OUTD, "$(INSTR)$(NAME):THRESH4 PP")
- field(OUTE, "$(INSTR)$(NAME):THRESH5 PP")
- field(OUTF, "$(INSTR)$(NAME):THRESH6 PP")
- field(OUTG, "$(INSTR)$(NAME):THRESH7 PP")
- field(OUTH, "$(INSTR)$(NAME):THRESH8 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_THRESH PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_THRESH PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_THRESH PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_THRESH PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_THRESH PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_THRESH PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_THRESH PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_THRESH PP")
 }
 
 record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F2")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):THRESH9 PP")
- field(OUTB, "$(INSTR)$(NAME):THRESH10 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH9_THRESH PP")
+ field(OUTB, "$(INSTR)$(NAME):CH10_THRESH PP")
 }
 
 ################################################################################
diff --git a/db/daq_4ch.db b/db/daq_4ch.db
index 81a3bf8..87cb984 100644
--- a/db/daq_4ch.db
+++ b/db/daq_4ch.db
@@ -28,37 +28,27 @@ record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 record(ai, "$(INSTR)$(NAME):HW_MT")
 {
  field(DESC, "Monitor threshold to actually use")
- field(INP,  "$(INSTR)$(NAME):MT1 NPP")
+ field(INP,  "$(INSTR)$(NAME):CH1_PRESET NPP")
 }
 
 record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):MT1 PP")
- field(OUTB, "$(INSTR)$(NAME):MT2 PP")
- field(OUTC, "$(INSTR)$(NAME):MT3 PP")
- field(OUTD, "$(INSTR)$(NAME):MT4 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_PRESET PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_PRESET PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_PRESET PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_PRESET PP")
 }
 
-# record(dfanout,"$(INSTR)$(NAME):RESET_MT")
-# {
-#  field(OMSL, "supervisory")
-#  field(SELM, "All")
-#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
-#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
-#  field(OUTC, "$(INSTR)$(NAME):RESET_MT3 PP")
-#  field(OUTD, "$(INSTR)$(NAME):RESET_MT4 PP")
-# }
-
 record(dfanout,"$(INSTR)$(NAME):CMONITORS")
 {
  field(SELM, "All")
  field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):C1 PP")
- field(OUTB, "$(INSTR)$(NAME):C2 PP")
- field(OUTC, "$(INSTR)$(NAME):C3 PP")
- field(OUTD, "$(INSTR)$(NAME):C4 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR PP")
 }
 
 ################################################################################
@@ -71,10 +61,10 @@ record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):THRESH1 PP")
- field(OUTB, "$(INSTR)$(NAME):THRESH2 PP")
- field(OUTC, "$(INSTR)$(NAME):THRESH3 PP")
- field(OUTD, "$(INSTR)$(NAME):THRESH4 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_THRESH PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_THRESH PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_THRESH PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_THRESH PP")
 }
 
 ################################################################################
diff --git a/db/daq_8ch.db b/db/daq_8ch.db
index ece1e16..675d3fb 100644
--- a/db/daq_8ch.db
+++ b/db/daq_8ch.db
@@ -28,49 +28,35 @@ record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 record(ai, "$(INSTR)$(NAME):HW_MT")
 {
  field(DESC, "Monitor threshold to actually use")
- field(INP,  "$(INSTR)$(NAME):MT1 NPP")
+ field(INP,  "$(INSTR)$(NAME):CH1_PRESET NPP")
 }
 
 record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):MT1 PP")
- field(OUTB, "$(INSTR)$(NAME):MT2 PP")
- field(OUTC, "$(INSTR)$(NAME):MT3 PP")
- field(OUTD, "$(INSTR)$(NAME):MT4 PP")
- field(OUTE, "$(INSTR)$(NAME):MT5 PP")
- field(OUTF, "$(INSTR)$(NAME):MT6 PP")
- field(OUTG, "$(INSTR)$(NAME):MT7 PP")
- field(OUTH, "$(INSTR)$(NAME):MT8 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_PRESET PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_PRESET PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_PRESET PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_PRESET PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_PRESET PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_PRESET PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_PRESET PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_PRESET PP")
 }
 
-# record(dfanout,"$(INSTR)$(NAME):RESET_MT")
-# {
-#  field(OMSL, "supervisory")
-#  field(SELM, "All")
-#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
-#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
-#  field(OUTC, "$(INSTR)$(NAME):RESET_MT3 PP")
-#  field(OUTD, "$(INSTR)$(NAME):RESET_MT4 PP")
-#  field(OUTE, "$(INSTR)$(NAME):RESET_MT5 PP")
-#  field(OUTF, "$(INSTR)$(NAME):RESET_MT6 PP")
-#  field(OUTG, "$(INSTR)$(NAME):RESET_MT7 PP")
-#  field(OUTH, "$(INSTR)$(NAME):RESET_MT8 PP")
-# }
-
 record(dfanout,"$(INSTR)$(NAME):CMONITORS")
 {
  field(SELM, "All")
  field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):C1 PP")
- field(OUTB, "$(INSTR)$(NAME):C2 PP")
- field(OUTC, "$(INSTR)$(NAME):C3 PP")
- field(OUTD, "$(INSTR)$(NAME):C4 PP")
- field(OUTE, "$(INSTR)$(NAME):C5 PP")
- field(OUTF, "$(INSTR)$(NAME):C6 PP")
- field(OUTG, "$(INSTR)$(NAME):C7 PP")
- field(OUTH, "$(INSTR)$(NAME):C8 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_CLEAR PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_CLEAR PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_CLEAR PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_CLEAR PP")
 }
 
 ################################################################################
@@ -83,14 +69,14 @@ record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):THRESH1 PP")
- field(OUTB, "$(INSTR)$(NAME):THRESH2 PP")
- field(OUTC, "$(INSTR)$(NAME):THRESH3 PP")
- field(OUTD, "$(INSTR)$(NAME):THRESH4 PP")
- field(OUTE, "$(INSTR)$(NAME):THRESH5 PP")
- field(OUTF, "$(INSTR)$(NAME):THRESH6 PP")
- field(OUTG, "$(INSTR)$(NAME):THRESH7 PP")
- field(OUTH, "$(INSTR)$(NAME):THRESH8 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH1_THRESH PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_THRESH PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_THRESH PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_THRESH PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_THRESH PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_THRESH PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_THRESH PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_THRESH PP")
 }
 
 ################################################################################
diff --git a/db/daq_common.db b/db/daq_common.db
index 554465d..eda311d 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -5,6 +5,7 @@
 # NAME - the device name, e.g. EL737
 # PROTO - Stream device protocol file
 # ASYN_PORT - Low level Asyn IP Port to EL737
+# POLL_FREQ - Scan string defining main status-loop polling frequency (default .5 second)
 
 # Send initial initialisation commands
 record(bo, "$(INSTR)$(NAME):INIT-CONF")
@@ -85,8 +86,8 @@ record(mbbiDirect, "$(INSTR)$(NAME):RAW-STATUS")
 {
  field(DESC, "Raw returned status value")
  field(DTYP, "stream")
- field(SCAN, ".5 second")
- field(INP, "@$(PROTO) readStatus($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(SCAN, "$(POLL_FREQ=.5 second)")
+ field(INP,  "@$(PROTO) readStatus($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(FLNK, "$(INSTR)$(NAME):READALL")
 }
 
@@ -340,7 +341,7 @@ record(ao, "$(INSTR)$(NAME):FAKE-HW-COUNT")
 {
  field(DESC, "Count forever :)")
  field(OMSL, "closed_loop")
- field(DOL,  "15768000") # Half a year
+ field(DOL,  "15768000") # Half a year :)
  field(OUT, "$(INSTR)$(NAME):HW_ETT")
  field(FLNK, "$(INSTR)$(NAME):PRESET-TIME")
 }
-- 
2.52.0


From 521deaa921ff06d40d79e4d8c5843a50eba31c9b Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Fri, 5 Jun 2026 13:13:07 +0200
Subject: [PATCH 6/8] moves time channel specific to own file and makes similar
 to channel file

---
 Makefile                |   1 +
 db/channels.db          |  17 +++---
 db/daq.proto            |  20 +++---
 db/daq_2nd_gen.db       | 105 +++++++++++---------------------
 db/daq_4ch.db           |  30 ++++-----
 db/daq_8ch.db           |  38 ++++++------
 db/daq_common.db        | 127 +++++++-------------------------------
 db/time.db              | 132 ++++++++++++++++++++++++++++++++++++++++
 scripts/daq_2nd_gen.cmd |   2 +
 scripts/daq_4ch.cmd     |   2 +
 scripts/daq_8ch.cmd     |   2 +
 11 files changed, 252 insertions(+), 224 deletions(-)
 create mode 100644 db/time.db

diff --git a/Makefile b/Makefile
index 8e7762c..367c1d3 100644
--- a/Makefile
+++ b/Makefile
@@ -13,6 +13,7 @@ REQUIRED+=stream
 
 # DB files to include in the release
 TEMPLATES += db/channels.db
+TEMPLATES += db/time.db
 TEMPLATES += db/gating_channels.db
 TEMPLATES += db/daq_4ch.db
 TEMPLATES += db/daq_8ch.db
diff --git a/db/channels.db b/db/channels.db
index 72469e6..df3b66b 100644
--- a/db/channels.db
+++ b/db/channels.db
@@ -49,7 +49,7 @@ record(dfanout, "$(INSTR)$(NAME):CH$(CHANNEL)_POLL")
  field(OMSL, "closed_loop")
  field(DOL,  1)
  field(OUTA, "$(INSTR)$(NAME):CH$(CHANNEL)_HWCS.PROC")
- field(OUTB, "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW.PROC")
+ field(OUTB, "$(INSTR)$(NAME):CH$(CHANNEL)_STS_RAW.PROC")
  field(OUTC, "$(INSTR)$(NAME):CH$(CHANNEL)_REACHED.PROC")
 }
 
@@ -58,6 +58,7 @@ record(dfanout, "$(INSTR)$(NAME):CH$(CHANNEL)_POLL")
 
 record(bi, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED")
 {
+ field(DESC, "are hw counts being cleared")
  field(VAL,  0)
  field(ZNAM, "Cleared")
  field(ONAM, "Clearing")
@@ -66,7 +67,7 @@ record(bi, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED")
 # Trigger a change in status as value returned to 0
 record(seq, "$(INSTR)$(NAME):CH$(CHANNEL)_HWCS")
 {
- field(DESC, "Trigger Returned to 0 Status")
+ field(DESC, "Trigger returned to 0 status")
  field(SELM, "Specified")
  field(SELL, "$(INSTR)$(NAME):CH$(CHANNEL).VAL")
  field(DO0,  0)
@@ -95,9 +96,9 @@ record(longout, "$(INSTR)$(NAME):CH$(CHANNEL)_HWC")
 ################################################################################
 # Determining Channel Status
 
-record(calc, "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW")
+record(calc, "$(INSTR)$(NAME):CH$(CHANNEL)_STS_RAW")
 {
- field(DESC, "Channel Status")
+ field(DESC, "Raw Channel Status")
  field(INPA, "$(INSTR)$(NAME):STATUS NPP")
  field(INPB, "$(INSTR)$(NAME):CH$(CHANNEL)_CLEARED NPP")
  field(INPC, "$(INSTR)$(NAME):CH$(CHANNEL)_SET NPP")
@@ -109,7 +110,7 @@ record(calc, "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW")
 record(mbbi, "$(INSTR)$(NAME):CH$(CHANNEL)_STS")
 {
  field(DESC, "Channel Status")
- field(INP,  "$(INSTR)$(NAME):CH$(CHANNEL)_STSRAW NPP MS")
+ field(INP,  "$(INSTR)$(NAME):CH$(CHANNEL)_STS_RAW NPP MS")
  field(ZRVL, "0")
  field(ZRST, "Idle")
  field(ONVL, "1")
@@ -142,7 +143,7 @@ record(calcout, "$(INSTR)$(NAME):CH$(CHANNEL)_REACHED")
 
 record(bi, "$(INSTR)$(NAME):CH$(CHANNEL)_SET")
 {
- field(DESC, "Channel Status")
+ field(DESC, "is preset being configured")
  field(VAL,  0)
  field(ZNAM, "Set")
  field(ONAM, "Setting")
@@ -180,7 +181,7 @@ record(dfanout, "$(INSTR)$(NAME):CH$(CHANNEL)_SETTING")
 record(calcout, "$(INSTR)$(NAME):CH$(CHANNEL)_IN_HW")
 {
  field(DESC, "Possible to configure in HW")
- field(INPA, "$(INSTR)$(NAME):PRESET-TYPE NPP")
+ field(INPA, "$(INSTR)$(NAME):PRESET_TYPE NPP")
  field(INPB, "$(INSTR)$(NAME):CH$(CHANNEL)_PRESET NPP")
  field(INPC, "$(INSTR)$(NAME):MONITOR-CHANNEL.DRVH NPP")
  field(CALC, "A=0 && B>0 && $(CHANNEL)<=C")
@@ -203,7 +204,7 @@ record(ao, "$(INSTR)$(NAME):CH$(CHANNEL)_SET_PTYPE")
 {
  field(OMSL, "closed_loop")
  field(DOL,  2)
- field(OUT,  "$(INSTR)$(NAME):PRESET-TYPE PP")
+ field(OUT,  "$(INSTR)$(NAME):PRESET_TYPE PP")
 }
 
 ################################################################################
diff --git a/db/daq.proto b/db/daq.proto
index 18f9fe0..ff1af45 100644
--- a/db/daq.proto
+++ b/db/daq.proto
@@ -1,12 +1,12 @@
 #
 #  SinqDAQ Protocol File
-#  
+#
 OutTerminator = CR;
 InTerminator  = CR;
-ReadTimeout    = 100;
-WriteTimeout   = 100;
-ReplyTimeout   = 1000;
-LockTimeout    = 500;
+ReadTimeout   = 100;
+WriteTimeout  = 100;
+ReplyTimeout  = 1000;
+LockTimeout   = 500;
 
 initialise {
  out "RMT 1"; # Turn on Remote Control
@@ -141,25 +141,25 @@ readRateMonitor{
 
 readAll4 {
  out "RA";
- in "%(\$1ELAPSED-TIME)f %(\$1M1)d %(\$1M2)d %(\$1M3)d %(\$1M4)d";
+ in "%(\$1T)f %(\$1CH1)d %(\$1CH2)d %(\$1CH3)d %(\$1CH4)d";
  @mismatch{in "%(\$1MsgTxt)s";}
 }
 
 readAll8 {
  out "RA";
- in "%(\$1ELAPSED-TIME)f %(\$1M1)d %(\$1M2)d %(\$1M3)d %(\$1M4)d %(\$1M5)d %(\$1M6)d %(\$1M7)d %(\$1M8)d";
+ in "%(\$1T)f %(\$1CH1)d %(\$1CH2)d %(\$1CH3)d %(\$1CH4)d %(\$1CH5)d %(\$1CH6)d %(\$1CH7)d %(\$1CH8)d";
  @mismatch{in "%(\$1MsgTxt)s";}
 }
 
 readAll10 {
  out "RA";
- in "%(\$1ELAPSED-TIME)f %(\$1M1)d %(\$1M2)d %(\$1M3)d %(\$1M4)d %(\$1M5)d %(\$1M6)d %(\$1M7)d %(\$1M8)d";
+ in "%(\$1T)f %(\$1CH1)d %(\$1CH2)d %(\$1CH3)d %(\$1CH4)d %(\$1CH5)d %(\$1CH6)d %(\$1CH7)d %(\$1CH8)d";
  # At least on the sinqtest variant this is broken
  # requiring channels 9 and 10 to be manually queried
  out "RC 9";
- in "%(\$1M9)d";
+ in "%(\$1CH9)d";
  out "RC 10";
- in "%(\$1M10)d";
+ in "%(\$1CH10)d";
  @mismatch{in "%(\$1MsgTxt)s";}
 }
 
diff --git a/db/daq_2nd_gen.db b/db/daq_2nd_gen.db
index 512e303..ff03e73 100644
--- a/db/daq_2nd_gen.db
+++ b/db/daq_2nd_gen.db
@@ -20,18 +20,17 @@ record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
  field(FLNK, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV.PROC")
 }
 
-# TODO we might need to make sure we wait, when the channel is changed
 record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 {
  field(DESC, "PRESET-COUNT Monitors this channel")
  field(DTYP, "stream")
  field(INP, "@$(PROTO) readPresetMonitor($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(SCAN, ".5 second")
- field(FLNK, "$(INSTR)$(NAME):CORRECT-MONITOR-CHANNEL.PROC")
+ field(FLNK, "$(INSTR)$(NAME):CORRECT_MONITOR_CHANNEL.PROC")
 }
 
 # Force back to 1 if it is 0, as 0 has no meaning...
-record(seq, "$(INSTR)$(NAME):CORRECT-MONITOR-CHANNEL")
+record(seq, "$(INSTR)$(NAME):CORRECT_MONITOR_CHANNEL")
 {
  field(SELM, "Specified")
  field(SELL, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV.VAL NPP")
@@ -39,7 +38,7 @@ record(seq, "$(INSTR)$(NAME):CORRECT-MONITOR-CHANNEL")
  field(LNK0, "$(INSTR)$(NAME):MONITOR-CHANNEL PP")
 }
 
-record(sel, "$(INSTR)$(NAME):HW_MT")
+record(sel, "$(INSTR)$(NAME):CH_PRESET")
 {
  field(DESC, "Monitor threshold to actually use")
  field(SELM, "Specified")
@@ -57,16 +56,17 @@ record(sel, "$(INSTR)$(NAME):HW_MT")
  field(INPK, "$(INSTR)$(NAME):CH10_PRESET NPP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
+record(dfanout,"$(INSTR)$(NAME):CH_PRESET_CLEAR")
 {
+ field(DESC, "Clears all channel presets")
  field(SELM, "All")
  field(OMSL, "closed_loop")
  field(DOL,  1)
- field(OUTA, "$(INSTR)$(NAME):RESET_HW_MT1.PROC")
- field(OUTB, "$(INSTR)$(NAME):RESET_HW_MT2.PROC")
+ field(OUTA, "$(INSTR)$(NAME):CH_PRESET_CLEAR1.PROC")
+ field(OUTB, "$(INSTR)$(NAME):CH_PRESET_CLEAR2.PROC")
 }
 
-record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT1")
+record(dfanout,"$(INSTR)$(NAME):CH_PRESET_CLEAR1")
 {
  field(SELM, "All")
  field(OMSL, "closed_loop")
@@ -81,7 +81,7 @@ record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT1")
  field(OUTH, "$(INSTR)$(NAME):CH8_PRESET PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT2")
+record(dfanout,"$(INSTR)$(NAME):CH_PRESET_CLEAR2")
 {
  field(SELM, "All")
  field(OMSL, "closed_loop")
@@ -90,82 +90,54 @@ record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT2")
  field(OUTB, "$(INSTR)$(NAME):CH10_PRESET PP")
 }
 
-# record(dfanout,"$(INSTR)$(NAME):RESET_MT")
-# {
-#  field(DESC, "Resets Internal Variables")
-#  field(SELM, "All")
-#  field(OMSL, "supervisory")
-#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
-#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
-# }
-#
-# record(dfanout,"$(INSTR)$(NAME):RESET_MT1")
-# {
-#  field(SELM, "All")
-#  field(OMSL, "supervisory")
-#  field(OUTA, "$(INSTR)$(NAME):RESET_MT1 PP")
-#  field(OUTB, "$(INSTR)$(NAME):RESET_MT2 PP")
-#  field(OUTC, "$(INSTR)$(NAME):RESET_MT3 PP")
-#  field(OUTD, "$(INSTR)$(NAME):RESET_MT4 PP")
-#  field(OUTE, "$(INSTR)$(NAME):RESET_MT5 PP")
-#  field(OUTF, "$(INSTR)$(NAME):RESET_MT6 PP")
-#  field(OUTG, "$(INSTR)$(NAME):RESET_MT7 PP")
-#  field(OUTH, "$(INSTR)$(NAME):RESET_MT8 PP")
-# }
-#
-# record(dfanout,"$(INSTR)$(NAME):RESET_MT2")
-# {
-#  field(SELM, "All")
-#  field(OMSL, "supervisory")
-#  field(OUTA, "$(INSTR)$(NAME):RESET_MT9 PP")
-#  field(OUTB, "$(INSTR)$(NAME):RESET_MT10 PP")
-# }
-
-record(dfanout,"$(INSTR)$(NAME):CMONITORS")
+record(dfanout,"$(INSTR)$(NAME):CH_CLEAR")
 {
+ field(DESC, "Clears all channel counts")
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):CMONITORS1 PP")
- field(OUTB, "$(INSTR)$(NAME):CMONITORS2 PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH_CLEAR1.PROC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH_CLEAR2.PROC PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):CMONITORS1")
+record(dfanout,"$(INSTR)$(NAME):CH_CLEAR1")
 {
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR PP")
- field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR PP")
- field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR PP")
- field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR PP")
- field(OUTE, "$(INSTR)$(NAME):CH5_CLEAR PP")
- field(OUTF, "$(INSTR)$(NAME):CH6_CLEAR PP")
- field(OUTG, "$(INSTR)$(NAME):CH7_CLEAR PP")
- field(OUTH, "$(INSTR)$(NAME):CH8_CLEAR PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR.PROC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR.PROC PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR.PROC PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR.PROC PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_CLEAR.PROC PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_CLEAR.PROC PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_CLEAR.PROC PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_CLEAR.PROC PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):CMONITORS2")
+record(dfanout,"$(INSTR)$(NAME):CH_CLEAR2")
 {
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):CH9_CLEAR PP")
- field(OUTB, "$(INSTR)$(NAME):CH10_CLEAR PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH9_CLEAR.PROC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH10_CLEAR.PROC PP")
 }
 
 ################################################################################
-# Count Commands
-
 # The hardware stores a separate threshold for each channel, which is somewhat
 # unintuitive for the user, as only one can actually be made use of at a time.
 # So, we just write the threshold value to all channels when it is changed.
-record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
+record(dfanout,"$(INSTR)$(NAME):CH_THRESHOLD")
 {
+ field(DESC, "Sets Channel Lowrate Thresholds")
  field(OMSL, "supervisory")
  field(SELM, "All")
- field(OUTA, "$(INSTR)$(NAME):THRESHOLD-F1 PP")
- field(OUTB, "$(INSTR)$(NAME):THRESHOLD-F2 PP")
+ field(OUTA, "$(INSTR)$(NAME):CH_THRESHOLD1 PP")
+ field(OUTB, "$(INSTR)$(NAME):CH_THRESHOLD2 PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F1")
+record(dfanout,"$(INSTR)$(NAME):CH_THRESHOLD1")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
@@ -179,13 +151,10 @@ record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F1")
  field(OUTH, "$(INSTR)$(NAME):CH8_THRESH PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F2")
+record(dfanout,"$(INSTR)$(NAME):CH_THRESHOLD2")
 {
  field(OMSL, "supervisory")
  field(SELM, "All")
  field(OUTA, "$(INSTR)$(NAME):CH9_THRESH PP")
  field(OUTB, "$(INSTR)$(NAME):CH10_THRESH PP")
 }
-
-################################################################################
-# Read all monitors values
diff --git a/db/daq_4ch.db b/db/daq_4ch.db
index 87cb984..3fd4367 100644
--- a/db/daq_4ch.db
+++ b/db/daq_4ch.db
@@ -25,40 +25,43 @@ record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
  field(DISP, 1)
 }
 
-record(ai, "$(INSTR)$(NAME):HW_MT")
+record(ai, "$(INSTR)$(NAME):CH_PRESET")
 {
  field(DESC, "Monitor threshold to actually use")
  field(INP,  "$(INSTR)$(NAME):CH1_PRESET NPP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
+record(dfanout,"$(INSTR)$(NAME):CH_PRESET_CLEAR")
 {
- field(OMSL, "supervisory")
+ field(DESC, "Clears all channel presets")
  field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  0)
  field(OUTA, "$(INSTR)$(NAME):CH1_PRESET PP")
  field(OUTB, "$(INSTR)$(NAME):CH2_PRESET PP")
  field(OUTC, "$(INSTR)$(NAME):CH3_PRESET PP")
  field(OUTD, "$(INSTR)$(NAME):CH4_PRESET PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):CMONITORS")
+record(dfanout,"$(INSTR)$(NAME):CH_CLEAR")
 {
+ field(DESC, "Clears all channel counts")
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR PP")
- field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR PP")
- field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR PP")
- field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR.PROC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR.PROC PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR.PROC PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR.PROC PP")
 }
 
 ################################################################################
-# Count Commands
-
 # The hardware stores a separate threshold for each channel, which is somewhat
 # unintuitive for the user, as only one can actually be made use of at a time.
 # So, we just write the threshold value to all channels when it is changed.
-record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
+record(dfanout,"$(INSTR)$(NAME):CH_THRESHOLD")
 {
+ field(DESC, "Sets Channel Lowrate Thresholds")
  field(OMSL, "supervisory")
  field(SELM, "All")
  field(OUTA, "$(INSTR)$(NAME):CH1_THRESH PP")
@@ -66,6 +69,3 @@ record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
  field(OUTC, "$(INSTR)$(NAME):CH3_THRESH PP")
  field(OUTD, "$(INSTR)$(NAME):CH4_THRESH PP")
 }
-
-################################################################################
-# Read all monitors values
diff --git a/db/daq_8ch.db b/db/daq_8ch.db
index 675d3fb..27b628a 100644
--- a/db/daq_8ch.db
+++ b/db/daq_8ch.db
@@ -25,16 +25,18 @@ record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
  field(DISP, 1)
 }
 
-record(ai, "$(INSTR)$(NAME):HW_MT")
+record(ai, "$(INSTR)$(NAME):CH_PRESET")
 {
  field(DESC, "Monitor threshold to actually use")
  field(INP,  "$(INSTR)$(NAME):CH1_PRESET NPP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
+record(dfanout,"$(INSTR)$(NAME):CH_PRESET_CLEAR")
 {
- field(OMSL, "supervisory")
+ field(DESC, "Clears all channel presets")
  field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  0)
  field(OUTA, "$(INSTR)$(NAME):CH1_PRESET PP")
  field(OUTB, "$(INSTR)$(NAME):CH2_PRESET PP")
  field(OUTC, "$(INSTR)$(NAME):CH3_PRESET PP")
@@ -45,28 +47,29 @@ record(dfanout,"$(INSTR)$(NAME):RESET_HW_MT")
  field(OUTH, "$(INSTR)$(NAME):CH8_PRESET PP")
 }
 
-record(dfanout,"$(INSTR)$(NAME):CMONITORS")
+record(dfanout,"$(INSTR)$(NAME):CH_CLEAR")
 {
+ field(DESC, "Clears all channel counts")
  field(SELM, "All")
- field(OMSL, "supervisory")
- field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR PP")
- field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR PP")
- field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR PP")
- field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR PP")
- field(OUTE, "$(INSTR)$(NAME):CH5_CLEAR PP")
- field(OUTF, "$(INSTR)$(NAME):CH6_CLEAR PP")
- field(OUTG, "$(INSTR)$(NAME):CH7_CLEAR PP")
- field(OUTH, "$(INSTR)$(NAME):CH8_CLEAR PP")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):CH1_CLEAR.PROC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH2_CLEAR.PROC PP")
+ field(OUTC, "$(INSTR)$(NAME):CH3_CLEAR.PROC PP")
+ field(OUTD, "$(INSTR)$(NAME):CH4_CLEAR.PROC PP")
+ field(OUTE, "$(INSTR)$(NAME):CH5_CLEAR.PROC PP")
+ field(OUTF, "$(INSTR)$(NAME):CH6_CLEAR.PROC PP")
+ field(OUTG, "$(INSTR)$(NAME):CH7_CLEAR.PROC PP")
+ field(OUTH, "$(INSTR)$(NAME):CH8_CLEAR.PROC PP")
 }
 
 ################################################################################
-# Count Commands
-
 # The hardware stores a separate threshold for each channel, which is somewhat
 # unintuitive for the user, as only one can actually be made use of at a time.
 # So, we just write the threshold value to all channels when it is changed.
-record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
+record(dfanout,"$(INSTR)$(NAME):CH_THRESHOLD")
 {
+ field(DESC, "Sets Channel Lowrate Thresholds")
  field(OMSL, "supervisory")
  field(SELM, "All")
  field(OUTA, "$(INSTR)$(NAME):CH1_THRESH PP")
@@ -78,6 +81,3 @@ record(dfanout,"$(INSTR)$(NAME):THRESHOLD-F")
  field(OUTG, "$(INSTR)$(NAME):CH7_THRESH PP")
  field(OUTH, "$(INSTR)$(NAME):CH8_THRESH PP")
 }
-
-################################################################################
-# Read all monitors values
diff --git a/db/daq_common.db b/db/daq_common.db
index eda311d..2e9ff53 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -32,13 +32,13 @@ record(dfanout, "$(INSTR)$(NAME):RESET")
  # Internal Count Timer
  field(OUTA, "$(INSTR)$(NAME):COUNT_STARTED PP")
  # Time Preset
- # field(OUTB, "$(INSTR)$(NAME):HW_ETT PP")
- # field(OUTC, "$(INSTR)$(NAME):ET_CLEARED PP")
+ # field(OUTB, "$(INSTR)$(NAME):T_PRESET PP")
+ # field(OUTC, "$(INSTR)$(NAME):T_CLEARED PP")
  # Monitor Presets
- # field(OUTD, "$(INSTR)$(NAME):RESET_HW_MT PP")
+ # field(OUTD, "$(INSTR)$(NAME):CH_PRESET_CLEAR PP")
  # field(OUTE, "$(INSTR)$(NAME):RESET_MT PP")
  # HW Preset Type
- # field(OUTF, "$(INSTR)$(NAME):PRESET-TYPE PP")
+ # field(OUTF, "$(INSTR)$(NAME):PRESET_TYPE PP")
 }
 
 ################################################################################
@@ -162,39 +162,39 @@ record(mbbi, "$(INSTR)$(NAME):STATUS")
  # 4 should never happen, if it does it means the DAQ reports undocumented statusbits
  field(FRVL, "4")
  field(FRST, "INVALID")
- field(FLNK, "$(INSTR)$(NAME):RESET-P-PRESET")
+ field(FLNK, "$(INSTR)$(NAME):PRESET_TYPE_CLEAR")
 }
 
-record(calcout, "$(INSTR)$(NAME):RESET-P-PRESET")
+record(calcout, "$(INSTR)$(NAME):PRESET_TYPE_CLEAR")
 {
  field(INPA, "$(INSTR)$(NAME):STATUS NPP")
  field(CALC, "A")
  field(OOPT, "Transition To Zero")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
- field(OUT, "$(INSTR)$(NAME):PRESET-TYPE PP")
- field(FLNK, "$(INSTR)$(NAME):RESET-HW_ETT")
+ field(OUT,  "$(INSTR)$(NAME):PRESET_TYPE PP")
+ field(FLNK, "$(INSTR)$(NAME):T_PRESET_CLEAR")
 }
 
-record(calcout, "$(INSTR)$(NAME):RESET-HW_ETT")
+record(calcout, "$(INSTR)$(NAME):T_PRESET_CLEAR")
 {
  field(INPA, "$(INSTR)$(NAME):STATUS NPP")
  field(CALC, "A")
  field(OOPT, "Transition To Zero")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
- field(OUT, "$(INSTR)$(NAME):HW_ETT PP")
- field(FLNK, "$(INSTR)$(NAME):RESET-HW-PRESET")
+ field(OUT,  "$(INSTR)$(NAME):T_PRESET PP")
+ field(FLNK, "$(INSTR)$(NAME):PRESET_CLEAR")
 }
 
-record(calcout, "$(INSTR)$(NAME):RESET-HW-PRESET")
+record(calcout, "$(INSTR)$(NAME):PRESET_CLEAR")
 {
  field(INPA, "$(INSTR)$(NAME):STATUS NPP")
  field(CALC, "A")
  field(OOPT, "Transition To Zero")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
- field(OUT, "$(INSTR)$(NAME):RESET_HW_MT PP")
+ field(OUT, "$(INSTR)$(NAME):CH_PRESET_CLEAR PP")
  field(FLNK, "$(INSTR)$(NAME):Z_COUNT_STARTED")
 }
 
@@ -217,76 +217,10 @@ record(longin, "$(INSTR)$(NAME):CHANNELS")
  field(DISP, 1)
 }
 
-# Trigger a change in status as clearing
-record(bo, "$(INSTR)$(NAME):ETT")
-{
- field(DESC, "Trigger Clearing Status")
- field(VAL, 1)
- field(OUT, "$(INSTR)$(NAME):ET_CLEARED PP")
-}
-
-# Trigger a change in status as value returned to 0
-record(seq, "$(INSTR)$(NAME):ETO")
-{
- field(DESC, "Trigger Returned to 0 Status")
- field(LNK0, "$(INSTR)$(NAME):ET_CLEARED PP")
- field(DO0, 0)
- field(SELM, "Specified")
- field(SELL, "$(INSTR)$(NAME):ELAPSED-TIME.VAL")
- field(FLNK, "$(INSTR)$(NAME):ETS")
-}
-
-# Current Status of Channel, i.e. is it ready to count?
-record(bi, "$(INSTR)$(NAME):ET_CLEARED")
-{
- field(DESC, "Channel Status")
- field(VAL, 0)
- field(ZNAM, "CLEARED")
- field(ONAM, "CLEARING")
-}
-
-record(calc, "$(INSTR)$(NAME):ETS")
-{
- field(DESC, "Stupid Nicos Stuff")
- field(INPA, "$(INSTR)$(NAME):STATUS NPP")
- field(INPB, "$(INSTR)$(NAME):ET_CLEARED NPP")
- field(CALC, "A == 1 || B")
- field(FLNK, "$(INSTR)$(NAME):ETCHECK")
-}
-
-# Time Threshold
-record(int64in, "$(INSTR)$(NAME):HW_ETT")
-{
- field(DESC, "Time Threshold")
- field(VAL, 0)
- field(FLNK, "$(INSTR)$(NAME):SET-TYPE-TIME")
-}
-
-# Stop the count, if threshold is reached
-record(calcout, "$(INSTR)$(NAME):ETCHECK")
-{
-  field(INPA, "$(INSTR)$(NAME):ELAPSED-TIME NPP")
-  field(INPB, "$(INSTR)$(NAME):HW_ETT NPP")
-  field(CALC, "B > 0 && A >= B")
-  field(OOPT, "When Non-zero")
-  field(OUT, "$(INSTR)$(NAME):STOP.PROC")
-}
-
-record(calcout, "$(INSTR)$(NAME):SET-TYPE-TIME")
-{
- field(INPA, "$(INSTR)$(NAME):PRESET-TYPE NPP")
- field(INPB, "$(INSTR)$(NAME):HW_ETT NPP")
- field(CALC, "A=0 && B>0")
- field(OOPT, "When Non-zero")
- field(DOPT, "Use OCAL")
- field(OCAL, "1")
- field(OUT, "$(INSTR)$(NAME):PRESET-TYPE PP")
-}
-
 ################################################################################
 # Count Commands
 
-record(mbbi, "$(INSTR)$(NAME):PRESET-TYPE")
+record(mbbi, "$(INSTR)$(NAME):PRESET_TYPE")
 {
  field(DESC, "Type of Hardware Preset")
  field(ZRVL, "0")
@@ -311,8 +245,8 @@ record(dfanout,"$(INSTR)$(NAME):PREPARE")
  field(SELM, "All")
  field(OMSL, "supervisory")
  # Elapsed Time
- field(OUTA, "$(INSTR)$(NAME):CT PP")
- field(OUTB, "$(INSTR)$(NAME):CMONITORS PP")
+ field(OUTA, "$(INSTR)$(NAME):T_HWC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH_CLEAR PP")
  field(FLNK, "$(INSTR)$(NAME):TRIGGER")
 }
 
@@ -320,13 +254,13 @@ record(seq,"$(INSTR)$(NAME):TRIGGER")
 {
  field(DESC, "Actually triggers sending start")
  field(DO0, 1)
- field(LNK0, "$(INSTR)$(NAME):FAKE-HW-COUNT.PROC")
+ field(LNK0, "$(INSTR)$(NAME):PRESET-SOFT.PROC")
  field(DO1, 1)
  field(LNK1, "$(INSTR)$(NAME):PRESET-TIME.PROC")
  field(DO2, 1)
  field(LNK2, "$(INSTR)$(NAME):PRESET-COUNT.PROC")
  field(SELM, "Specified")
- field(SELL, "$(INSTR)$(NAME):PRESET-TYPE NPP")
+ field(SELL, "$(INSTR)$(NAME):PRESET_TYPE NPP")
  field(FLNK, "$(INSTR)$(NAME):O_COUNT_STARTED")
 }
 
@@ -337,12 +271,12 @@ record(longout, "$(INSTR)$(NAME):O_COUNT_STARTED")
  field(OUT, "$(INSTR)$(NAME):COUNT_STARTED PP")
 }
 
-record(ao, "$(INSTR)$(NAME):FAKE-HW-COUNT")
+record(ao, "$(INSTR)$(NAME):PRESET-SOFT")
 {
  field(DESC, "Count forever :)")
  field(OMSL, "closed_loop")
  field(DOL,  "15768000") # Half a year :)
- field(OUT, "$(INSTR)$(NAME):HW_ETT")
+ field(OUT, "$(INSTR)$(NAME):T_PRESET")
  field(FLNK, "$(INSTR)$(NAME):PRESET-TIME")
 }
 
@@ -351,7 +285,7 @@ record(ao,"$(INSTR)$(NAME):PRESET-TIME")
  field(DESC, "Count for specified time")
  field(DTYP, "stream")
  field(OMSL, "closed_loop")
- field(DOL,  "$(INSTR)$(NAME):HW_ETT NPP")
+ field(DOL,  "$(INSTR)$(NAME):T_PRESET NPP")
  field(OUT, "@$(PROTO) startWithTimePreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(PREC, 2)
  field(EGU, "seconds")
@@ -363,7 +297,7 @@ record(ao,"$(INSTR)$(NAME):PRESET-COUNT")
  field(DESC, "Count until preset reached")
  field(DTYP, "stream")
  field(OMSL, "closed_loop")
- field(DOL,  "$(INSTR)$(NAME):HW_MT PP")
+ field(DOL,  "$(INSTR)$(NAME):CH_PRESET PP")
  field(OUT, "@$(PROTO) startWithCountPreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(PREC, 0)
  field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
@@ -405,7 +339,7 @@ record(ao,"$(INSTR)$(NAME):THRESHOLD")
  field(DRVH, "100000") # Maximum Rate
  field(OMSL, "supervisory")
  field(OROC, "0")
- field(OUT, "$(INSTR)$(NAME):THRESHOLD-F PP")
+ field(OUT, "$(INSTR)$(NAME):CH_THRESHOLD PP")
 }
 
 record(ai,"$(INSTR)$(NAME):THRESHOLD_RBV")
@@ -446,14 +380,6 @@ record(calcout, "$(INSTR)$(NAME):THRESHOLD-MONITOR-FLNK")
  field(OUT, "$(INSTR)$(NAME):THRESHOLD_RBV.PROC PP")
 }
 
-record(longout, "$(INSTR)$(NAME):CT")
-{
- field(DESC, "Clear the timer")
- field(DTYP, "stream")
- field(OUT, "@$(PROTO) clearTimer($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(FLNK, "$(INSTR)$(NAME):ETT")
-}
-
 ################################################################################
 # Read all monitors values
 
@@ -464,10 +390,3 @@ record(ai, "$(INSTR)$(NAME):READALL")
  field(DTYP, "stream")
  field(FLNK, "$(INSTR)$(NAME):MAP-STATUS")
 }
-
-record(ai,"$(INSTR)$(NAME):ELAPSED-TIME")
-{
- field(DESC, "DAQ Measured Time")
- field(EGU, "sec")
- field(FLNK, "$(INSTR)$(NAME):ETO")
-}
diff --git a/db/time.db b/db/time.db
new file mode 100644
index 0000000..cdc539e
--- /dev/null
+++ b/db/time.db
@@ -0,0 +1,132 @@
+# EPICS Database for streamdevice specific to time channel
+#
+# Macros
+# INSTR - Prefix
+# NAME - the device name, e.g. EL737
+# PROTO - Stream device protocol file
+# ASYN_PORT - Low level Asyn IP Port to DAQ
+
+################################################################################
+# Time Channel Specific
+
+# Updated by READALL, at POLL_FREQ frequency
+record(ai,"$(INSTR)$(NAME):T")
+{
+ field(DESC, "DAQ Measured Time")
+ field(EGU, "sec")
+ field(FLNK, "$(INSTR)$(NAME):T_POLL")
+}
+
+################################################################################
+# Poll Loop
+
+record(dfanout, "$(INSTR)$(NAME):T_POLL")
+{
+ field(DESC, "Channel $(CHANNEL) poll sequence")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):T_HWCS.PROC")
+ field(OUTB, "$(INSTR)$(NAME):T_STS_RAW.PROC")
+ field(OUTC, "$(INSTR)$(NAME):TIME_REACHED.PROC")
+}
+
+################################################################################
+# Clearing Time
+
+# Current Status of Channel, i.e. is it ready to count?
+record(bi, "$(INSTR)$(NAME):T_CLEARED")
+{
+ field(DESC, "is hw time being cleared")
+ field(VAL, 0)
+ field(ZNAM, "Cleared")
+ field(ONAM, "Clearing")
+}
+
+# Trigger a change in status as value returned to 0
+record(seq, "$(INSTR)$(NAME):T_HWCS")
+{
+ field(DESC, "Trigger returned to 0 status")
+ field(LNK0, "$(INSTR)$(NAME):T_CLEARED PP")
+ field(DO0, 0)
+ field(SELM, "Specified")
+ field(SELL, "$(INSTR)$(NAME):T.VAL")
+}
+
+# Trigger a change in status as clearing
+record(dfanout, "$(INSTR)$(NAME):T_CLEAR")
+{
+ field(DESC, "Clears the time channel count")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):T_CLEARED PP")
+ field(OUTB, "$(INSTR)$(NAME):T_HWC.PROC PP")
+}
+
+record(longout, "$(INSTR)$(NAME):T_HWC")
+{
+ field(DESC, "Clear in Hardware")
+ field(DTYP, "stream")
+ field(OMSL, "closed_loop")
+ field(DOL,  "1")
+ field(OUT,  "@$(PROTO) clearTimer($(INSTR)$(NAME):) $(ASYN_PORT)")
+}
+
+################################################################################
+# Determining Time Channel Status
+
+record(calc, "$(INSTR)$(NAME):T_STS_RAW")
+{
+ field(DESC, "Raw time channel status")
+ field(INPA, "$(INSTR)$(NAME):STATUS NPP MS")
+ field(INPB, "$(INSTR)$(NAME):T_CLEARED NPP")
+ field(CALC, "A == 1 || B")
+ field(FLNK, "$(INSTR)$(NAME):T_STS")
+}
+
+# Current Status of Channel, i.e. is it ready for a new operation?
+record(mbbi, "$(INSTR)$(NAME):T_STS")
+{
+ field(DESC, "Time channel status")
+ field(INP,  "$(INSTR)$(NAME):T_STS_RAW NPP MS")
+ field(ZRVL, "0")
+ field(ZRST, "Idle")
+ field(ONVL, "1")
+ field(ONST, "Busy")
+}
+
+################################################################################
+# Time Channel Preset
+
+# If set, stop count once preset reached
+record(int64in, "$(INSTR)$(NAME):T_PRESET")
+{
+ field(DESC, "Time Preset")
+ field(VAL, 0)
+ field(FLNK, "$(INSTR)$(NAME):TIME_SET_PTYPE")
+}
+
+record(calcout, "$(INSTR)$(NAME):TIME_REACHED")
+{
+ field(DESC, "Stop if preset reached")
+ field(INPA, "$(INSTR)$(NAME):T NPP")
+ field(INPB, "$(INSTR)$(NAME):T_PRESET NPP")
+ field(CALC, "B > 0 && A >= B")
+ field(OOPT, "When Non-zero")
+ field(OUT, "$(INSTR)$(NAME):STOP.PROC")
+}
+
+################################################################################
+# Setting Time Channel Preset
+
+record(calcout, "$(INSTR)$(NAME):TIME_SET_PTYPE")
+{
+ field(INPA, "$(INSTR)$(NAME):PRESET_TYPE NPP")
+ field(INPB, "$(INSTR)$(NAME):T_PRESET NPP")
+ field(CALC, "A=0 && B>0")
+ field(OOPT, "When Non-zero")
+ field(DOPT, "Use OCAL")
+ field(OCAL, "1")
+ field(OUT, "$(INSTR)$(NAME):PRESET_TYPE PP")
+}
diff --git a/scripts/daq_2nd_gen.cmd b/scripts/daq_2nd_gen.cmd
index f9879cf..8f0d8f1 100644
--- a/scripts/daq_2nd_gen.cmd
+++ b/scripts/daq_2nd_gen.cmd
@@ -15,6 +15,8 @@ drvAsynIPPortConfigure("ASYN_$(NAME)", "$($(NAME)_DAQ_HOST)", 0,   0,   0)
 dbLoadRecords("$(sinqDAQ_DB)daq_common.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNELS=10, RATE_OKAY_BIT=$(RATE_OKAY_BIT=0)")
 dbLoadRecords("$(sinqDAQ_DB)daq_2nd_gen.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNELS=10")
 
+dbLoadRecords("$(sinqDAQ_DB)time.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME)")
+
 # Could also use substitions instead.
 dbLoadRecords("$(sinqDAQ_DB)channels.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNEL=1")
 dbLoadRecords("$(sinqDAQ_DB)channels.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNEL=2")
diff --git a/scripts/daq_4ch.cmd b/scripts/daq_4ch.cmd
index 208dfc1..a896616 100644
--- a/scripts/daq_4ch.cmd
+++ b/scripts/daq_4ch.cmd
@@ -15,6 +15,8 @@ drvAsynIPPortConfigure("ASYN_$(NAME)", "$($(NAME)_DAQ_HOST)", 0,   0,   0)
 dbLoadRecords("$(sinqDAQ_DB)daq_common.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNELS=4, RATE_OKAY_BIT=$(RATE_OKAY_BIT=0)")
 dbLoadRecords("$(sinqDAQ_DB)daq_4ch.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME)")
 
+dbLoadRecords("$(sinqDAQ_DB)time.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME)")
+
 # Could also use substitions instead.
 dbLoadRecords("$(sinqDAQ_DB)channels.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNEL=1")
 dbLoadRecords("$(sinqDAQ_DB)channels.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNEL=2")
diff --git a/scripts/daq_8ch.cmd b/scripts/daq_8ch.cmd
index af2f1be..58dcf57 100644
--- a/scripts/daq_8ch.cmd
+++ b/scripts/daq_8ch.cmd
@@ -15,6 +15,8 @@ drvAsynIPPortConfigure("ASYN_$(NAME)", "$($(NAME)_DAQ_HOST)", 0,   0,   0)
 dbLoadRecords("$(sinqDAQ_DB)daq_common.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNELS=8, RATE_OKAY_BIT=$(RATE_OKAY_BIT=0)")
 dbLoadRecords("$(sinqDAQ_DB)daq_8ch.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME)")
 
+dbLoadRecords("$(sinqDAQ_DB)time.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME)")
+
 # Could also use substitions instead.
 dbLoadRecords("$(sinqDAQ_DB)channels.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNEL=1")
 dbLoadRecords("$(sinqDAQ_DB)channels.db", "INSTR=$(INSTR), NAME=$(NAME), PROTO=$(PROTO), ASYN_PORT=ASYN_$(NAME), CHANNEL=2")
-- 
2.52.0


From 008a879d75b123d10a0ed00e7b0924c0dce6f9c1 Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Fri, 5 Jun 2026 14:22:05 +0200
Subject: [PATCH 7/8] fixes tests

---
 db/time.db     |  2 +-
 sim/daq_sim.py |  6 +++---
 test/test.py   | 29 +++++++++++++++++------------
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/db/time.db b/db/time.db
index cdc539e..54a3094 100644
--- a/db/time.db
+++ b/db/time.db
@@ -22,7 +22,7 @@ record(ai,"$(INSTR)$(NAME):T")
 
 record(dfanout, "$(INSTR)$(NAME):T_POLL")
 {
- field(DESC, "Channel $(CHANNEL) poll sequence")
+ field(DESC, "Time channel poll sequence")
  field(SELM, "All")
  field(OMSL, "closed_loop")
  field(DOL,  1)
diff --git a/sim/daq_sim.py b/sim/daq_sim.py
index d4da2ee..1116132 100644
--- a/sim/daq_sim.py
+++ b/sim/daq_sim.py
@@ -134,7 +134,7 @@ class DAQ:
 
             if self.getMonitorCount() >= self.presetcount:
                 self.counts[self.monitor] = self.presetcount if self.presetcount > 0 else self.counts[self.monitor]
-                self.status = 0            
+                self.status = 0
 
         else:
             raise Exception("Invalid State")
@@ -191,7 +191,7 @@ class DAQ:
     def setGate(self, channel, highlow):
         self.gate[channel - 1] = highlow
 
-        
+
 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
 
     s.bind((HOST, PORT))
@@ -216,7 +216,7 @@ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                 received = ''
             logger.info(f'RECEIVED: "{received}"')
             return received
-        
+
         daq = DAQ(TOTAL_CH)
 
         while True:
diff --git a/test/test.py b/test/test.py
index c7d45ff..af5dce4 100755
--- a/test/test.py
+++ b/test/test.py
@@ -42,31 +42,36 @@ def get_piped_output(proc):
 
 def getState(instr, name):
     result = run(['caget', f'{instr}{name}:STATUS'], stdout=PIPE)
-    state = result.stdout.decode('ascii').rstrip().split()[1] 
+    state = result.stdout.decode('ascii').rstrip().split()[1]
     print(f'Currently in state {state}')
     return state
 
 def getCount(instr, name, ch):
-    result = run(['caget', f'{instr}{name}:M{ch}'], stdout=PIPE)
+    result = run(['caget', f'{instr}{name}:CH{ch}'], stdout=PIPE)
     count = int(result.stdout.decode('ascii').rstrip().split()[1])
-    print(f'M{ch} == {count}')
+    print(f'CH{ch} == {count}')
     return count
 
 def presetTime(instr, name, time):
-    print(f'Starting count for {time} seconds')
-    run(['caput', f'{instr}{name}:PRESET-TIME', f'{time}'])
+    print(f'Setting preset on time channel of {time} seconds')
+    run(['caput', f'{instr}{name}:T_PRESET', f'{time}'])
 
-def presetCount(instr, name, count):
-    print(f'Starting count until channel 1 reaches {count}')
-    run(['caput', f'{instr}{name}:PRESET-COUNT', f'{count}'])
+def presetCount(instr, name, channel, count):
+    print(f'Setting preset on channel {channel} of {count} counts')
+    run(['caput', f'{instr}{name}:CH{channel}_PRESET', f'{count}'])
+
+def startCount(instr, name):
+    print('Starting Count')
+    run(['caput', f'{instr}{name}:START', '1'])
 
 def testCanCount(instr, name):
     # Check in Idle State
     assert getState(instr, name) == 'Idle', 'Not in valid state'
-    
+
     # Start Time Based Count and Check that Status Changes
     assert getCount(instr, name, 1) == 0, "Erroneous nonzero starting count value"
     presetTime(instr, name, 5)
+    startCount(instr, name)
     time.sleep(1)
     assert getState(instr, name) == 'Counting', 'Didn\'t start counting'
     time.sleep(5)
@@ -74,8 +79,10 @@ def testCanCount(instr, name):
     assert getCount(instr, name, 1) > 0, 'No events were counted'
 
     # Start Monitor Based Count and Check that Status Changes
+    presetChannel = 1
     presetAmount = 100
-    presetCount(instr, name, presetAmount)
+    presetCount(instr, name, presetChannel, presetAmount)
+    startCount(instr, name)
     time.sleep(1)
     assert getState(instr, name) == 'Counting', 'Didn\'t start counting'
     assert getCount(instr, name, 1) < presetAmount
@@ -99,8 +106,6 @@ def test(instr, name):
             if 'iocRun: All initialization complete' in line:
                 break # IOC is now running
 
-        #time.sleep(20)
-
         print("IOC Initialisation Complete")
         print("Starting Tests")
 
-- 
2.52.0


From 4904c473b7185ca39f55136d8477862010d7fee2 Mon Sep 17 00:00:00 2001
From: Edward Wall <edward.wall@psi.ch>
Date: Fri, 5 Jun 2026 16:21:21 +0200
Subject: [PATCH 8/8] all have a poll loop record

---
 db/daq_2nd_gen.db |   4 +-
 db/daq_4ch.db     |   4 +-
 db/daq_8ch.db     |   4 +-
 db/daq_common.db  | 321 ++++++++++++++++++++++++----------------------
 4 files changed, 176 insertions(+), 157 deletions(-)

diff --git a/db/daq_2nd_gen.db b/db/daq_2nd_gen.db
index ff03e73..1cc206d 100644
--- a/db/daq_2nd_gen.db
+++ b/db/daq_2nd_gen.db
@@ -12,7 +12,7 @@
 
 record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
 {
- field(DESC, "PRESET-COUNT Monitors this channel")
+ field(DESC, "PRESET_COUNT Monitors this channel")
  field(DRVL, "1") # Smallest Monitor Channel
  field(DRVH, "$(CHANNELS)") # Largest Monitor Channel
  field(DTYP, "stream")
@@ -22,7 +22,7 @@ record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
 
 record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 {
- field(DESC, "PRESET-COUNT Monitors this channel")
+ field(DESC, "PRESET_COUNT Monitors this channel")
  field(DTYP, "stream")
  field(INP, "@$(PROTO) readPresetMonitor($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(SCAN, ".5 second")
diff --git a/db/daq_4ch.db b/db/daq_4ch.db
index 3fd4367..9a0ce9d 100644
--- a/db/daq_4ch.db
+++ b/db/daq_4ch.db
@@ -11,7 +11,7 @@
 
 record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
 {
- field(DESC, "PRESET-COUNT Monitors this channel")
+ field(DESC, "PRESET_COUNT Monitors this channel")
  field(VAL, 1)
  field(DRVL, 0) # Smallest Monitor Channel (should really be 1)
  field(DRVH, 1) # Largest Monitor Channel
@@ -20,7 +20,7 @@ record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
 
 record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 {
- field(DESC, "PRESET-COUNT Monitors this channel")
+ field(DESC, "PRESET_COUNT Monitors this channel")
  field(VAL, 1)
  field(DISP, 1)
 }
diff --git a/db/daq_8ch.db b/db/daq_8ch.db
index 27b628a..bdb001a 100644
--- a/db/daq_8ch.db
+++ b/db/daq_8ch.db
@@ -11,7 +11,7 @@
 
 record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
 {
- field(DESC, "PRESET-COUNT Monitors this channel")
+ field(DESC, "PRESET_COUNT Monitors this channel")
  field(VAL, 1)
  field(DRVL, 0) # Smallest Monitor Channel (should really be 1)
  field(DRVH, 1) # Largest Monitor Channel
@@ -20,7 +20,7 @@ record(longout, "$(INSTR)$(NAME):MONITOR-CHANNEL")
 
 record(longin, "$(INSTR)$(NAME):MONITOR-CHANNEL_RBV")
 {
- field(DESC, "PRESET-COUNT Monitors this channel")
+ field(DESC, "PRESET_COUNT Monitors this channel")
  field(VAL, 1)
  field(DISP, 1)
 }
diff --git a/db/daq_common.db b/db/daq_common.db
index 2e9ff53..4823f71 100644
--- a/db/daq_common.db
+++ b/db/daq_common.db
@@ -7,6 +7,9 @@
 # ASYN_PORT - Low level Asyn IP Port to EL737
 # POLL_FREQ - Scan string defining main status-loop polling frequency (default .5 second)
 
+################################################################################
+# Hardware Initialisation
+
 # Send initial initialisation commands
 record(bo, "$(INSTR)$(NAME):INIT-CONF")
 {
@@ -30,7 +33,7 @@ record(dfanout, "$(INSTR)$(NAME):RESET")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  # Internal Count Timer
- field(OUTA, "$(INSTR)$(NAME):COUNT_STARTED PP")
+ field(OUTA, "$(INSTR)$(NAME):WAIT_HW PP")
  # Time Preset
  # field(OUTB, "$(INSTR)$(NAME):T_PRESET PP")
  # field(OUTC, "$(INSTR)$(NAME):T_CLEARED PP")
@@ -41,16 +44,6 @@ record(dfanout, "$(INSTR)$(NAME):RESET")
  # field(OUTF, "$(INSTR)$(NAME):PRESET_TYPE PP")
 }
 
-################################################################################
-# Status Variables
-
-record(stringin, "$(INSTR)$(NAME):MsgTxt")
-{
- field(DESC, "Unexpected received response")
- field(DTYP, "devDAQStringError")
- field(FLNK, "$(INSTR)$(NAME):INVALID-CONFIG")
-}
-
 # We want to recognise the invalid config error message, so that we can rerun
 # the init if it occurs. This should only happen after turning the DAQ off and
 # on again or running a full reset
@@ -70,37 +63,52 @@ record(seq, "$(INSTR)$(NAME):REINIT-CONF")
  field(SELL, "$(INSTR)$(NAME):INVALID-CONFIG.VAL")
 }
 
-# Important! The "$(INSTR)$(NAME):READALL" isn't configure with a SCAN. Instead,
-# it must always be triggered after the value of $(INSTR)$(NAME):RAW-STATUS is
-# updated, so that it can't be the case that the status changes back from
-# counting to idle, without having updated the time and count values.
-#
-# The status can be interpreted as follows
-#
-# Bit 0: NC_STAT_P_TIME_C
-# Bit 1: NC_STAT_P_COUNT_C
-# Bit 2: NC_STAT_RATE_OK_C It appears this should be ignored unless counting
-# Bit 3: NC_STAT_PAUSE_C
-#
-record(mbbiDirect, "$(INSTR)$(NAME):RAW-STATUS")
+################################################################################
+# Hardware Box Specific
+
+record(longin, "$(INSTR)$(NAME):CHANNELS")
 {
- field(DESC, "Raw returned status value")
- field(DTYP, "stream")
- field(SCAN, "$(POLL_FREQ=.5 second)")
- field(INP,  "@$(PROTO) readStatus($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(FLNK, "$(INSTR)$(NAME):READALL")
+ field(DESC, "Total Supported Channels")
+ field(VAL, $(CHANNELS))
+ field(DISP, 1)
 }
 
+record(mbbi, "$(INSTR)$(NAME):PRESET_TYPE")
+{
+ field(DESC, "Type of Hardware Preset")
+ field(ZRVL, "0")
+ field(ZRST, "Unset")
+ field(ONVL, "1")
+ field(ONST, "Time")
+ field(TWVL, "2")
+ field(TWST, "Monitor")
+}
+
+record(longin, "$(INSTR)$(NAME):WAIT_HW")
+{
+ field(DESC, "Internal Sent Start Count")
+}
+
+record(stringin, "$(INSTR)$(NAME):MsgTxt")
+{
+ field(DESC, "Unexpected received response")
+ field(DTYP, "devDAQStringError")
+ field(FLNK, "$(INSTR)$(NAME):INVALID-CONFIG")
+}
+
+################################################################################
+# System Status
+
 record(bi, "$(INSTR)$(NAME):COUNTING_TIME")
 {
- field(INP, "$(INSTR)$(NAME):RAW-STATUS.B0 NPP MS")
+ field(INP, "$(INSTR)$(NAME):RAW_STATUS.B0 NPP MS")
  field(ZNAM, "DISABLED")
  field(ONAM, "COUNTING")
 }
 
 record(bi, "$(INSTR)$(NAME):COUNTING_PRESET")
 {
- field(INP, "$(INSTR)$(NAME):RAW-STATUS.B1 NPP MS")
+ field(INP, "$(INSTR)$(NAME):RAW_STATUS.B1 NPP MS")
  field(ZNAM, "DISABLED")
  field(ONAM, "COUNTING")
 }
@@ -108,7 +116,7 @@ record(bi, "$(INSTR)$(NAME):COUNTING_PRESET")
 record(calc, "$(INSTR)$(NAME):RATE_MAP")
 {
  field(DESC, "This bit is not consistent across DAQs")
- field(INPA, "$(INSTR)$(NAME):RAW-STATUS.B2 NPP MS")
+ field(INPA, "$(INSTR)$(NAME):RAW_STATUS.B2 NPP MS")
  field(CALC, "(A=$(RATE_OKAY_BIT))?0:1")
 }
 
@@ -121,36 +129,15 @@ record(bi, "$(INSTR)$(NAME):IS_LOWRATE")
 
 record(bi, "$(INSTR)$(NAME):IS_PAUSED")
 {
- field(INP, "$(INSTR)$(NAME):RAW-STATUS.B3 NPP MS")
+ field(INP, "$(INSTR)$(NAME):RAW_STATUS.B3 NPP MS")
  field(ZNAM, "RUNNING")
  field(ONAM, "PAUSED")
 }
 
-record(longin, "$(INSTR)$(NAME):COUNT_STARTED")
-{
- field(DESC, "Internal Sent Start Count")
- field(VAL,  0)
- field(PINI, "YES")
-}
-
-record(calc, "$(INSTR)$(NAME):MAP-STATUS")
-{
- field(DESC, "Maps Raw Status to State")
- field(INPA, "$(INSTR)$(NAME):INVALID-CONFIG NPP MS")
- field(INPB, "$(INSTR)$(NAME):RAW-STATUS.UDF NPP MS") # should also be invalid if can't read the status
- field(INPC, "$(INSTR)$(NAME):COUNTING_TIME PP MS")
- field(INPD, "$(INSTR)$(NAME):COUNTING_PRESET PP MS")
- field(INPE, "$(INSTR)$(NAME):IS_LOWRATE PP MS")
- field(INPF, "$(INSTR)$(NAME):IS_PAUSED PP MS")
- field(INPG, "$(INSTR)$(NAME):COUNT_STARTED NPP MS")
- field(CALC, "(A=1||B=1)?4:(F=1)?3:(C=0&&D=0&&G<=0)?0:(E=1)?2:1")
- field(FLNK, "$(INSTR)$(NAME):STATUS")
-}
-
 record(mbbi, "$(INSTR)$(NAME):STATUS")
 {
  field(DESC, "DAQ Status")
- field(INP, "$(INSTR)$(NAME):MAP-STATUS NPP MS")
+ field(INP, "$(INSTR)$(NAME):MAP_STATUS NPP MS")
  field(ZRVL, "0")
  field(ZRST, "Idle")
  field(ONVL, "1")
@@ -162,7 +149,103 @@ record(mbbi, "$(INSTR)$(NAME):STATUS")
  # 4 should never happen, if it does it means the DAQ reports undocumented statusbits
  field(FRVL, "4")
  field(FRST, "INVALID")
- field(FLNK, "$(INSTR)$(NAME):PRESET_TYPE_CLEAR")
+}
+
+################################################################################
+# HW Commands
+
+record(dfanout,"$(INSTR)$(NAME):START")
+{
+ field(DESC, "clear, then trigger count")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(OUTA, "$(INSTR)$(NAME):T_HWC.PROC PP")
+ field(OUTB, "$(INSTR)$(NAME):CH_CLEAR.PROC PP")
+ field(FLNK, "$(INSTR)$(NAME):TRIGGER")
+}
+
+record(bo,"$(INSTR)$(NAME):PAUSE")
+{
+ field(DESC, "Pause the current count")
+ field(DTYP, "stream")
+ field(OUT, "@$(PROTO) pauseCount($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(VAL, "0")
+ field(FLNK, "$(INSTR)$(NAME):HW_POLL_SEQ")
+}
+
+record(bo,"$(INSTR)$(NAME):CONTINUE")
+{
+ field(DESC, "Continue with a count that was paused")
+ field(DTYP, "stream")
+ field(OUT, "@$(PROTO) continueCount($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(VAL, "0")
+ field(FLNK, "$(INSTR)$(NAME):HW_POLL_SEQ")
+}
+
+record(longout, "$(INSTR)$(NAME):STOP")
+{
+ field(DESC, "Stop the current counting operation")
+ field(DTYP, "stream")
+ field(OUT, "@$(PROTO) stopCount($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(FLNK, "$(INSTR)$(NAME):HW_POLL_SEQ")
+}
+
+################################################################################
+# Poll Loop
+
+record(bo, "$(INSTR)$(NAME):HW_POLL")
+{
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ field(SCAN, "$(POLL_FREQ=.5 second)")
+ field(OUT, "$(INSTR)$(NAME):HW_POLL_SEQ.PROC")
+}
+
+record(dfanout, "$(INSTR)$(NAME):HW_POLL_SEQ")
+{
+ field(DESC, "Time channel poll sequence")
+ field(SELM, "All")
+ field(OMSL, "closed_loop")
+ field(DOL,  1)
+ # This order is important, to ensure that the status
+ # can't change whichout having first updated the time
+ # and count records to their final values
+ field(OUTA, "$(INSTR)$(NAME):RAW_STATUS.PROC")
+ field(OUTB, "$(INSTR)$(NAME):READALL.PROC")
+ field(OUTC, "$(INSTR)$(NAME):MAP_STATUS.PROC")
+ field(OUTD, "$(INSTR)$(NAME):STATUS.PROC")
+ field(OUTE, "$(INSTR)$(NAME):PRESET_TYPE_CLEAR.PROC")
+ field(OUTF, "$(INSTR)$(NAME):T_PRESET_CLEAR.PROC")
+ field(OUTG, "$(INSTR)$(NAME):PRESET_CLEAR.PROC")
+ field(OUTH, "$(INSTR)$(NAME):CLEAR_WAIT_HW.PROC")
+}
+
+# The status can be interpreted as follows
+#
+# Bit 0: NC_STAT_P_TIME_C
+# Bit 1: NC_STAT_P_COUNT_C
+# Bit 2: NC_STAT_RATE_OK_C It appears this should be ignored unless counting
+# Bit 3: NC_STAT_PAUSE_C
+#
+record(mbbiDirect, "$(INSTR)$(NAME):RAW_STATUS")
+{
+ field(DESC, "Raw returned status value")
+ field(DTYP, "stream")
+ field(INP,  "@$(PROTO) readStatus($(INSTR)$(NAME):) $(ASYN_PORT)")
+}
+
+record(calc, "$(INSTR)$(NAME):MAP_STATUS")
+{
+ field(DESC, "Maps Raw Status to State")
+ field(INPA, "$(INSTR)$(NAME):INVALID-CONFIG NPP MS")
+ field(INPB, "$(INSTR)$(NAME):RAW_STATUS.UDF NPP MS") # should also be invalid if can't read the status
+ field(INPC, "$(INSTR)$(NAME):COUNTING_TIME PP MS")
+ field(INPD, "$(INSTR)$(NAME):COUNTING_PRESET PP MS")
+ field(INPE, "$(INSTR)$(NAME):IS_LOWRATE PP MS")
+ field(INPF, "$(INSTR)$(NAME):IS_PAUSED PP MS")
+ field(INPG, "$(INSTR)$(NAME):WAIT_HW NPP MS")
+ field(CALC, "(A=1||B=1)?4:(F=1)?3:(C=0&&D=0&&G<=0)?0:(E=1)?2:1")
 }
 
 record(calcout, "$(INSTR)$(NAME):PRESET_TYPE_CLEAR")
@@ -173,7 +256,6 @@ record(calcout, "$(INSTR)$(NAME):PRESET_TYPE_CLEAR")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
  field(OUT,  "$(INSTR)$(NAME):PRESET_TYPE PP")
- field(FLNK, "$(INSTR)$(NAME):T_PRESET_CLEAR")
 }
 
 record(calcout, "$(INSTR)$(NAME):T_PRESET_CLEAR")
@@ -184,7 +266,6 @@ record(calcout, "$(INSTR)$(NAME):T_PRESET_CLEAR")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
  field(OUT,  "$(INSTR)$(NAME):T_PRESET PP")
- field(FLNK, "$(INSTR)$(NAME):PRESET_CLEAR")
 }
 
 record(calcout, "$(INSTR)$(NAME):PRESET_CLEAR")
@@ -195,139 +276,78 @@ record(calcout, "$(INSTR)$(NAME):PRESET_CLEAR")
  field(DOPT, "Use OCAL")
  field(OCAL, "0")
  field(OUT, "$(INSTR)$(NAME):CH_PRESET_CLEAR PP")
- field(FLNK, "$(INSTR)$(NAME):Z_COUNT_STARTED")
 }
 
-record(calcout, "$(INSTR)$(NAME):Z_COUNT_STARTED")
+record(calcout, "$(INSTR)$(NAME):CLEAR_WAIT_HW")
 {
- field(INPA, "$(INSTR)$(NAME):COUNT_STARTED NPP")
+ field(INPA, "$(INSTR)$(NAME):WAIT_HW NPP")
  field(INPB, "$(INSTR)$(NAME):COUNTING_TIME NPP MS")
  field(INPC, "$(INSTR)$(NAME):COUNTING_PRESET NPP MS")
  field(CALC, "A")
  field(DOPT, "Use OCAL")
  field(OCAL, "(B||C)?0:A-1")
  field(OOPT, "When Non-zero")
- field(OUT, "$(INSTR)$(NAME):COUNT_STARTED PP")
-}
-
-record(longin, "$(INSTR)$(NAME):CHANNELS")
-{
- field(DESC, "Total Supported Channels")
- field(VAL, $(CHANNELS))
- field(DISP, 1)
+ field(OUT, "$(INSTR)$(NAME):WAIT_HW PP")
 }
 
 ################################################################################
-# Count Commands
-
-record(mbbi, "$(INSTR)$(NAME):PRESET_TYPE")
-{
- field(DESC, "Type of Hardware Preset")
- field(ZRVL, "0")
- field(ZRST, "Unset")
- field(ONVL, "1")
- field(ONST, "Time")
- field(TWVL, "2")
- field(TWST, "Monitor")
- field(VAL,  0)
- field(PINI, "YES")
-}
-
-record(bo,"$(INSTR)$(NAME):START")
-{
- field(DESC, "Zero, then trigger")
- field(FLNK, "$(INSTR)$(NAME):PREPARE")
-}
-
-record(dfanout,"$(INSTR)$(NAME):PREPARE")
-{
- field(DESC, "Zero channels")
- field(SELM, "All")
- field(OMSL, "supervisory")
- # Elapsed Time
- field(OUTA, "$(INSTR)$(NAME):T_HWC PP")
- field(OUTB, "$(INSTR)$(NAME):CH_CLEAR PP")
- field(FLNK, "$(INSTR)$(NAME):TRIGGER")
-}
+# Count Startup
 
 record(seq,"$(INSTR)$(NAME):TRIGGER")
 {
- field(DESC, "Actually triggers sending start")
- field(DO0, 1)
- field(LNK0, "$(INSTR)$(NAME):PRESET-SOFT.PROC")
- field(DO1, 1)
- field(LNK1, "$(INSTR)$(NAME):PRESET-TIME.PROC")
- field(DO2, 1)
- field(LNK2, "$(INSTR)$(NAME):PRESET-COUNT.PROC")
+ field(DESC, "Start count according to PRESET_TYPE")
  field(SELM, "Specified")
  field(SELL, "$(INSTR)$(NAME):PRESET_TYPE NPP")
- field(FLNK, "$(INSTR)$(NAME):O_COUNT_STARTED")
+ field(DO0,  1)
+ field(LNK0, "$(INSTR)$(NAME):PRESET_SOFT.PROC")
+ field(DO1,  1)
+ field(LNK1, "$(INSTR)$(NAME):PRESET_TIME.PROC")
+ field(DO2,  1)
+ field(LNK2, "$(INSTR)$(NAME):PRESET_COUNT.PROC")
+ field(FLNK, "$(INSTR)$(NAME):SET_WAIT_HW")
 }
 
-record(longout, "$(INSTR)$(NAME):O_COUNT_STARTED")
-{
- field(OMSL, "closed_loop")
- field(DOL,  5)
- field(OUT, "$(INSTR)$(NAME):COUNT_STARTED PP")
-}
-
-record(ao, "$(INSTR)$(NAME):PRESET-SOFT")
+record(ao, "$(INSTR)$(NAME):PRESET_SOFT")
 {
  field(DESC, "Count forever :)")
  field(OMSL, "closed_loop")
  field(DOL,  "15768000") # Half a year :)
- field(OUT, "$(INSTR)$(NAME):T_PRESET")
- field(FLNK, "$(INSTR)$(NAME):PRESET-TIME")
+ field(OUT,  "$(INSTR)$(NAME):T_PRESET")
+ field(FLNK, "$(INSTR)$(NAME):PRESET_TIME")
 }
 
-record(ao,"$(INSTR)$(NAME):PRESET-TIME")
+record(ao,"$(INSTR)$(NAME):PRESET_TIME")
 {
  field(DESC, "Count for specified time")
  field(DTYP, "stream")
  field(OMSL, "closed_loop")
  field(DOL,  "$(INSTR)$(NAME):T_PRESET NPP")
- field(OUT, "@$(PROTO) startWithTimePreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(OUT,  "@$(PROTO) startWithTimePreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(PREC, 2)
- field(EGU, "seconds")
- field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
+ field(EGU,  "seconds")
+ field(FLNK, "$(INSTR)$(NAME):HW_POLL_SEQ")
 }
 
-record(ao,"$(INSTR)$(NAME):PRESET-COUNT")
+record(ao,"$(INSTR)$(NAME):PRESET_COUNT")
 {
  field(DESC, "Count until preset reached")
  field(DTYP, "stream")
  field(OMSL, "closed_loop")
  field(DOL,  "$(INSTR)$(NAME):CH_PRESET PP")
- field(OUT, "@$(PROTO) startWithCountPreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
+ field(OUT,  "@$(PROTO) startWithCountPreset$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(PREC, 0)
- field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
+ field(FLNK, "$(INSTR)$(NAME):HW_POLL_SEQ")
 }
 
-record(bo,"$(INSTR)$(NAME):PAUSE")
+record(longout, "$(INSTR)$(NAME):SET_WAIT_HW")
 {
- field(DESC, "Pause the current count")
- field(DTYP, "stream")
- field(OUT, "@$(PROTO) pauseCount($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(VAL, "0")
- field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
+ field(OMSL, "closed_loop")
+ field(DOL,  5)
+ field(OUT,  "$(INSTR)$(NAME):WAIT_HW PP")
 }
 
-record(bo,"$(INSTR)$(NAME):CONTINUE")
-{
- field(DESC, "Continue with a count that was paused")
- field(DTYP, "stream")
- field(OUT, "@$(PROTO) continueCount($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(VAL, "0")
- field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
-}
-
-record(longout, "$(INSTR)$(NAME):STOP")
-{
- field(DESC, "Stop the current counting operation")
- field(DTYP, "stream")
- field(OUT, "@$(PROTO) stopCount($(INSTR)$(NAME):) $(ASYN_PORT)")
- field(FLNK, "$(INSTR)$(NAME):RAW-STATUS")
-}
+################################################################################
+# Hardware Lowrate Threshold
 
 record(ao,"$(INSTR)$(NAME):THRESHOLD")
 {
@@ -368,14 +388,14 @@ record(longin,"$(INSTR)$(NAME):THRESHOLD-MONITOR_RBV")
  field(DTYP, "stream")
  field(SCAN, "1 second")
  field(EGU, "CH")
- field(FLNK, "$(INSTR)$(NAME):THRESHOLD-MONITOR-FLNK")
+ field(FLNK, "$(INSTR)$(NAME):THR_MONITOR_PROCESS")
 }
 
-record(calcout, "$(INSTR)$(NAME):THRESHOLD-MONITOR-FLNK")
+record(calcout, "$(INSTR)$(NAME):THR_MONITOR_PROCESS")
 {
  field(DESC, "Only process Threshold when Non-Zero")
- field(CALC, "A")
  field(INPA, "$(INSTR)$(NAME):THRESHOLD-MONITOR_RBV")
+ field(CALC, "A")
  field(OOPT, "When Non-zero")
  field(OUT, "$(INSTR)$(NAME):THRESHOLD_RBV.PROC PP")
 }
@@ -388,5 +408,4 @@ record(ai, "$(INSTR)$(NAME):READALL")
  field(DESC, "Reads monitors and elapsed time")
  field(INP, "@$(PROTO) readAll$(CHANNELS)($(INSTR)$(NAME):) $(ASYN_PORT)")
  field(DTYP, "stream")
- field(FLNK, "$(INSTR)$(NAME):MAP-STATUS")
 }
-- 
2.52.0