# Template file for digital attenuator controlled by parallel digital outputs (e.g. Beckhoff)

record(stringout, "$(PRE):Name") {
    field(DESC, "Amp/Attn name")
    field(VAL,  "$(NAME="")")
    field(PINI, "1")
}

# This is the "public" attenuator setpoint
record(ao, "$(PRE):AttnSetpt") {
    field(DESC, "Attenuator setpt")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
# Limits are pushed in a dfanout below
    field(DRVL, "")
    field(DRVH, "")
    field(LOPR, "")
    field(HOPR, "")
    field(OUT,  "$(PRE):AttnSetpt_write PP")
}

# The next 3 records are for "closed loop" operation, if the output channels are
# changed outside this database (e.g. an IOC reboot or if someone changes an individual bit)
record(ao, "$(PRE):AttnSetpt_write") {
    field(ASG,  "Internal")
    field(SDIS, "$(PRE):AttnSetpt_sync.PACT")
    field(DISV, "1")
    field(FLNK, "$(PRE):AttnSetpt_calc")
}

record(ai, "$(PRE):AttnSetpt_RBV") {
    field(DESC, "Attenuator setpt RBV")
    field(ASG,  "Internal")
    field(INP,  "$(PRE):AttnSetpt_RBV_calc")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(LOLO, "")
    field(LOW,  "")
    field(HIGH, "")
    field(HIHI, "")
    field(LLSV, "MAJOR")
    field(LSV,  "")
    field(HSV,  "")
    field(HHSV, "")
    field(FLNK, "$(PRE):AttnSetpt_sync")
}

record(ao, "$(PRE):AttnSetpt_sync") {
    field(ASG,  "Internal")
    field(DOL,  "$(PRE):AttnSetpt_RBV NPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):AttnSetpt PP")
}

# Attenuator setpoint max and min values
record(ao, "$(PRE):AttnMaxVal") {
    field(DESC, "Max attenuation")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(VAL,  "$(MAX=31.75)")
    field(PINI, "1")
    field(FLNK, "$(PRE):AttnMaxVal_dfo")
}

record(dfanout, "$(PRE):AttnMaxVal_dfo") {
    field(ASG,  "Internal")
    field(DOL,  "$(PRE):AttnMaxVal")
    field(OMSL, "closed_loop")
    field(OUTA, "$(PRE):AttnSetpt.HOPR")
    field(OUTB, "$(PRE):AttnSetpt.DRVH")
}

record(ao, "$(PRE):AttnMinVal") {
    field(DESC, "Min attenuation")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(VAL,  "$(MIN=0)")
    field(PINI, "1")
    field(FLNK, "$(PRE):AttnMinVal_dfo")
}

record(dfanout, "$(PRE):AttnMinVal_dfo") {
    field(ASG,  "Internal")
    field(DOL,  "$(PRE):AttnMinVal")
    field(OMSL, "closed_loop")
    field(OUTA, "$(PRE):AttnSetpt.LOPR")
    field(OUTB, "$(PRE):AttnSetpt.DRVL")
    field(OUTC, "$(PRE):AttnSetpt_RBV.LOLO")
}

#----------------------------------------------------------------------

# Attenuator setpoint increase by one step ($(STEP=0.25) $(EGU=dB))
record(bo, "$(PRE):AttnSetptInc") {
    field(DESC, "Attenuator setpt increase")
    field(FLNK, "$(PRE):AttnSetptInc_calc")
}

record(calcout, "$(PRE):AttnSetptInc_calc") {
    field(DESC, "Attenuator setpt increase")
    field(ASG,  "Internal")
    field(INPA, "$(PRE):AttnSetpt")
    field(CALC, "A + $(STEP=0.25)")
    field(OUT,  "$(PRE):AttnSetpt PP")
}
#----------------------------------------------------------------------

# Attenuator setpoint decrease by one step ($(STEP=0.25) $(EGU=dB))
record(bo, "$(PRE):AttnSetptDec") {
    field(DESC, "Attenuator setpt decrease")
    field(FLNK, "$(PRE):AttnSetptDec_calc")
}

record(calcout, "$(PRE):AttnSetptDec_calc") {
    field(DESC, "Attenuator setpt decrease")
    field(ASG,  "Internal")
    field(INPA, "$(PRE):AttnSetpt")
    field(CALC, "A - $(STEP=0.25)")
    field(OUT,  "$(PRE):AttnSetpt PP")
}
#----------------------------------------------------------------------

# Go to max attenuation
record(seq, "$(PRE):AttnGoMax") {
    field(DESC, "Go to max attenuation")
    field(DOL1, "$(PRE):AttnMaxVal")
    field(LNK1, "$(PRE):AttnSetpt PP")
}
#----------------------------------------------------------------------

# Fwd Pwr Trip Check
# Comapre current and previous values to see if the amp has tripped off or lost power.
# If the values are above/below thresholds, go to max attenuation.
# Fault will reset automatically when the Fwd Pwr value updates.
# After 5 seconds reset the fault if it hasn't reset automatically.

record(compress, "$(PRE):FwdPwrHist") {
    field(DESC, "Fwd pwr history")
    field(INP,  "$(PRE):FwdPwr CP MS")
    field(ALG,  "Circular Buffer")
    field(NSAM, "2")
    field(FLNK, "$(PRE):FwdPwrPrev")
}

record(subArray, "$(PRE):FwdPwrPrev") {
    field(DESC, "Fwd pwr previous val")
    field(ASG,  "Internal")
    field(INP,  "$(PRE):FwdPwrHist")
    field(FTVL, "DOUBLE")
    field(MALM, "2")
    field(NELM, "1")
    field(INDX, "0")
    field(FLNK, "$(PRE):FwdPwrCheck")
}

record(bo, "$(PRE):FwdPwrCheckEnable") {
    field(DESC, "FWD power trip check Enable/Disable")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
    field(ZSV,  "MAJOR")
    field(VAL,  "1")
    field(PINI, "1")
    field(FLNK, "$(PRE):FwdPwrCheck")
}

record(calcout, "$(PRE):FwdPwrCheck") {
    field(DESC, "FWD power trip check")
    field(ASG,  "Internal")
    field(INPA, "$(PRE):FwdPwr")
    field(INPB, "$(PRE):FwdPwrPrev")
    field(INPC, "$(THRESH_LO=25)")
    field(INPD, "$(THRESH_UP=30)")
    field(INPE, "$(PRE):FwdPwrCheckEnable")
    field(CALC, "!(E&&((A<C)&&(B>D)))")
    field(OOPT, "Transition To Zero")
    field(OUT,  "$(PRE):FwdPwrCheckWait.PROC")
}

# Wait 5 seconds...
record(seq, "$(PRE):FwdPwrCheckWait") {
    field(DESC, "Fwd pwr wait and check")
    field(ASG,  "Internal")
    field(DLY1, "5")
    field(DOL1, "1")
    field(LNK1, "$(PRE):FwdPwrCheckClear.PROC")
}

# Clear fault if still active
record(calcout, "$(PRE):FwdPwrCheckClear") {
    field(DESC, "Fwd pwr wait and clear")
    field(ASG,  "Internal")
    field(INPA, "$(PRE):FwdPwrCheck")
    field(CALC, "A")
    field(OOPT, "When Zero")
    field(OUT,  "$(PRE):FwdPwrHist.PROC")
}

# Power conversions -----------------------------------------------
record(calc, "$(PRE):FwdPwrWatts_calc") {
    field(DESC, "FWD power in W")
    field(INPA, "$(PRE):FwdPwr CP MS")
    field(INPB, "1e-3")
    field(CALC, "B*10^(A/10)")
    field(FLNK, "$(PRE):FwdPwrWatts")
}

record(ai, "$(PRE):FwdPwrWatts") {
    field(DESC, "FWD power in W")
    field(EGU,  "W")
    field(PREC, "$(PREC=2)")
    field(INP, "$(PRE):FwdPwrWatts_calc NPP MS")
}

record(calc, "$(PRE):RefPwrWatts_calc") {
    field(DESC, "REF power in W")
    field(INPA, "$(PRE):RefPwr CP MS")
    field(INPB, "1e-3")
    field(CALC, "B*10^(A/10)")
    field(FLNK, "$(PRE):RefPwrWatts")
}

record(ai, "$(PRE):RefPwrWatts") {
    field(DESC, "REF power in W")
    field(EGU,  "W")
    field(PREC, "$(PREC=2)")
    field(INP, "$(PRE):RefPwrWatts_calc NPP MS")
}

# Sequencer records -----------------------------------------------
record(bi, "$(PRE):AmpFaultStatus") {
    field(DESC, "Amp fault status")
    field(ZNAM, "Fault")
    field(ONAM, "OK")
    field(ZSV,  "MAJOR")
    field(VAL,  "1")
    field(PINI, "1")
}

record(mbbo, "$(PRE):AmpStatusMsg") {
    field(DESC, "Amp status message")
    field(ZRVL, "0")
    field(ZRST, "OK")
    field(ONVL, "1")
    field(ONST, "Ramping...")
    field(ONSV, "MINOR")
    field(TWVL, "2")
    field(TWST, "Fault detected")
    field(TWSV, "MAJOR")
    field(THVL, "3")
    field(THST, "Fwd Pwr trip detected")
    field(THSV, "MAJOR")
    field(FRVL, "4")
    field(FRST, "Ramp failed")
    field(FRSV, "MAJOR")
    field(VAL,  "0")
}

record(ao, "$(PRE):AttnRampInitial") {
    field(DESC, "Initial ramp val")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(VAL,  "$(RI=23)")
    field(PINI, "1")
    field(FLNK, "$(PRE):AttnRampInc_calc")
}

record(ao, "$(PRE):AttnRampFinal") {
    field(DESC, "Final ramp val")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(VAL,  "$(RF=5)")
    field(PINI, "1")
    field(FLNK, "$(PRE):AttnRampInc_calc")
}

record(ao, "$(PRE):AttnTargetSetpt") {
    field(DESC, "Target setpt")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(VAL,  "$(TSETPT=3)")
    field(PINI, "1")
    field(FLNK, "$(PRE):AttnRampInc_calc")
}

record(longout, "$(PRE):AttnRampNumSteps") {
    field(DESC, "Number of steps for ramp seq")
    field(DRVL, "2")
    field(LOPR, "2")
    field(VAL,  "$(NS=17)")
    field(PINI, "1")
    field(FLNK, "$(PRE):AttnRampInc_calc")
}

record(longin, "$(PRE):AttnRampStepCnt") {
    field(DESC, "Ramp step count")
    field(VAL,  "0")
    field(PINI, "1")
}

record(calcout, "$(PRE):AttnRampInc_calc") {
    field(DESC, "Ramp increment")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
    field(INPA, "$(PRE):AttnRampInitial")
    field(INPB, "$(PRE):AttnTargetSetpt")
    field(INPC, "$(PRE):AttnRampNumSteps")
    field(CALC, "(B-A)/(C-1)")
    field(OUT,  "$(PRE):AttnRampInc PP")
}

record(ai, "$(PRE):AttnRampInc") {
    field(DESC, "Ramp increment")
    field(EGU,  "$(EGU=dB)")
    field(PREC, "$(PREC=2)")
}

record(longout, "$(PRE):AttnRampDelay") {
    field(DESC, "Delay between ramp steps")
    field(EGU,  "s")
    field(VAL,  "$(DT=5)")
    field(PINI, "1")
}

record(bo, "$(PRE):AttnRampDown") {
    field(DESC, "Start ramp")
    field(ZNAM, "Standby")
    field(ONAM, "Ramp")
    field(VAL,  "0")
    field(HIGH, "0.25")
    field(PINI, "1")
}

record(bo, "$(PRE):AttnRampAbort") {
    field(DESC, "Abort ramp")
    field(ZNAM, "Standby")
    field(ONAM, "Abort")
    field(VAL,  "0")
    field(PINI, "1")
}

record(bo, "$(PRE):AttnRampCheckEnable") {
    field(DESC, "Ramp check Enable/Disable")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
    field(ZSV,  "MAJOR")
    field(VAL,  "1")
    field(PINI, "1")
}

#----------------------------------------------------------------------

record(calc, "$(PRE):AttnSetpt_calc") {
    field(DESC, "Convert to integer")
    field(ASG,  "Internal")
    field(INPA, "$(PRE):AttnSetpt")
    field(CALC, "$(STEP=0.25)=0?A:(A/$(STEP=0.25))")
    field(FLNK, "$(PRE):Attn")
}

record(mbbiDirect, "$(PRE):Attn") {
    field(DESC, "Attenuator bits")
    field(ASG,  "Internal")
    field(INP,  "$(PRE):AttnSetpt_calc")
    field(FLNK, "$(PRE):Attn_Seq1")
}

# This pushes out bits and latches the attenuator
record(seq, "$(PRE):Attn_Seq1") {
    field(DESC, "Attenuator latch/set")
    field(ASG,  "Internal")
    field(DLY1, "0.0")
    field(DOL1, "0")
    field(LNK1, "$(LATCH) PP")
    field(DLY2, "0.0")
    field(DOL2, "$(PRE):Attn.B0")
    field(LNK2, "$(B0) PP")
    field(DLY3, "0.0")
    field(DOL3, "$(PRE):Attn.B1")
    field(LNK3, "$(B1) PP")
    field(DLY4, "0.0")
    field(DOL4, "$(PRE):Attn.B2")
    field(LNK4, "$(B2) PP")
    field(DLY5, "0.0")
    field(DOL5, "$(PRE):Attn.B3")
    field(LNK5, "$(B3) PP")
    field(DLY6, "0.0")
    field(DOL6, "$(PRE):Attn.B4")
    field(LNK6, "$(B4) PP")
    field(DLY7, "0.0")
    field(DOL7, "$(PRE):Attn.B5")
    field(LNK7, "$(B5) PP")
    field(DLY8, "0.0")
    field(DOL8, "$(PRE):Attn.B6")
    field(LNK8, "$(B6) PP")
    field(DLY9, "0.15")
    field(DOL9, "1")
    field(LNK9, "$(LATCH) PP")
    field(DLYA, "0.15")
    field(DOLA, "0")
    field(LNKA, "$(LATCH) PP")
}
#----------------------------------------------------------------------

# These records are for a readback of the digital output bits, and
# are used in the "closed loop" logic above
record(mbboDirect, "$(PRE):Attn_RBV") {
    field(DESC, "Attenuator bits RBV")
    field(ASG,  "Internal")
    field(FLNK, "$(PRE):AttnSetpt_RBV_calc")
}

record(calc, "$(PRE):AttnSetpt_RBV_calc") {
    field(DESC, "Attenuator setpt RBV calc")
    field(ASG,  "Internal")
    field(INPA, "$(PRE):Attn_RBV")
    field(CALC, "A*$(STEP=0.25)")
    field(FLNK, "$(PRE):AttnSetpt_RBV")
}

record(bo, "$(PRE):AttnBit0_RBV") {
    field(DESC, "Attenuator Bit0 RBV")
    field(DOL,  "$(B0) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B0 PP")
}

record(bo, "$(PRE):AttnBit1_RBV") {
    field(DESC, "Attenuator Bit1 RBV")
    field(DOL,  "$(B1) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B1 PP")
}

record(bo, "$(PRE):AttnBit2_RBV") {
    field(DESC, "Attenuator Bit2 RBV")
    field(DOL,  "$(B2) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B2 PP")
}

record(bo, "$(PRE):AttnBit3_RBV") {
    field(DESC, "Attenuator Bit3 RBV")
    field(DOL,  "$(B3) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B3 PP")
}

record(bo, "$(PRE):AttnBit4_RBV") {
    field(DESC, "Attenuator Bit4 RBV")
    field(DOL,  "$(B4) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B4 PP")
}

record(bo, "$(PRE):AttnBit5_RBV") {
    field(DESC, "Attenuator Bit5 RBV")
    field(DOL,  "$(B5) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B5 PP")
}

record(bo, "$(PRE):AttnBit6_RBV") {
    field(DESC, "Attenuator Bit6 RBV")
    field(DOL,  "$(B6) CPP")
    field(OMSL, "closed_loop")
    field(OUT,  "$(PRE):Attn_RBV.B6 PP")
}

#---  Latch readback -------------------------------------------------------------------
record(bi, "$(PRE):Latch_RBV") {
    field(DESC, "Attenuator latch RBV")
    field(INP,  "$(LATCH) CPP MS")
    field(ZNAM, "Off")
    field(ONAM, "On")
    field(OSV,  "MINOR")
}

#--- Alarm summaries -----------------------------------------------------
record(calc, "$(PRE):ExpertAlarmSum") {
  field(DESC, "Amp/Atten alarm summary")
  field(INPA, "$(PRE):FwdPwrCheckEnable.SEVR CP MS")
  field(INPB, "$(PRE):AttnRampCheckEnable.SEVR CP MS")
  field(CALC, "0")
  field(FLNK, "$(PRE):AlarmSummary")
}

record(calc, "$(PRE):AlarmSummary") {
  field(DESC, "Amp/Atten alarm summary")
  field(INPA, "$(PRE):AmpFaultStatus.SEVR CP MS")
  field(INPB, "$(PRE):FwdPwr.SEVR CP MS")
  field(INPC, "$(PRE):RefPwr.SEVR CP MS")
  field(INPD, "$(PRE):FwdPwrAlm.SEVR CP MS")
  field(INPE, "$(PRE):PSAlm.SEVR CP MS")
  field(INPF, "$(PRE):TempAlm.SEVR CP MS")
  field(INPG, "$(PRE):AttnSetpt_RBV.SEVR CP MS")
  field(INPH, "$(PRE):AmpStatusMsg.SEVR CP MS")
  field(INPI, "$(PRE):ExpertAlarmSum.SEVR NPP MS")
  field(CALC, "0")
}


