record(mbbi, "CPU:LTUH:PM01:TYPE_RAW") {
 field(DESC, "Device type")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm01+mch")
 field(ZRST, "Unknown")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "MicroTCA")
 field(ONVL, "1")
 field(ONSV, "NO_ALARM")
 field(TWST, "MicroTCA")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Supermicro")
 field(THVL, "3")
 field(THSV, "NO_ALARM")
 field(FRST, "ATCA")
 field(FRVL, "4")
 field(FRSV, "NO_ALARM")
 field(FVVL, "5")
 field(FVST, "ATCA")
 field(FVSV, "NO_ALARM")
 field(SXVL, "6")
 field(SXST, "Advantech")
 field(SXSV, "NO_ALARM")
 field(PINI, "YES")
}

record(stringin, "CPU:LTUH:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-04")
  info(autosaveFields,"VAL")
}

# Control debug message verbosity
record(mbbo, "CPU:LTUH:PM01:DBG") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "Off")
 field(ONVL, "1")
 field(ONST, "Low")
 field(TWVL, "2")
 field(TWST, "Med")
 field(THVL, "3")
 field(THST, "High")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-pm01+dbg")
 field(VAL,  "0")
 field(PINI, "YES")
}

record(bi, "CPU:LTUH:PM01:ONLNSTAT") {
 field(DESC, "MCH online status")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm01+stat")
 field(ZNAM, "Offline")
 field(ZSV, "MAJOR")
 field(ONAM, "Online")
 field(OSV, "NO_ALARM")
 field(PINI, "YES")
 alias("CPU:LTUH:PM01:STAT")
}

record(mbbi, "CPU:LTUH:PM01:INIT") {
 field(DESC, "MCH comm initialized")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm01+init")
 field(ZRST, "Not initialized")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "Initializing...")
 field(ONVL, "1")
 field(ONSV, "MINOR")
 field(TWST, "Initialized")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Initialize failed")
 field(THVL, "3")
 field(THSV, "MAJOR")
 field(PINI, "YES")
}

record(bo, "CPU:LTUH:PM01:INITBYP") {
 field(DESC, "Override init for testing")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-pm01+init")
 field(ZNAM, "Not initialized")
 field(ZSV, "MAJOR")
 field(ONAM, "Initialized")
 field(OSV, "NO_ALARM")
 field(PINI, "NO")
}

record(bo, "CPU:LTUH:PM01:CONNECT") {
 field(DESC, "Enable comm with MCH")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-pm01+sess")
 field(ZNAM, "Disconnect")
 field(ZSV,  "MAJOR")
 field(ONAM, "Connect")
 field(OSV,  "NO_ALARM")
 field(VAL, "1")
 field(RVAL, "1")
 field(PINI, "YES") 
 info(autosaveFields,"VAL RVAL")
}

# Add power on, power off, hard-reset, and msg
# PVs to be consistent with other SLAC systems       
record(bo, "CPU:LTUH:PM01:POWEROFF") {     
  field(DESC, "Power off system")            
  field(FLNK, "CPU:LTUH:PM01:POWEROFF1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:PM01:POWEROFF1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM01:POWEROFF2")
}  
record(longout, "CPU:LTUH:PM01:POWEROFF2") {     
  field(DESC, "Power off system")            
  field(DOL, "0")
  field(OUT, "CPU:LTUH:PM01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM01:POWEROFF3")
}  
record(calcout, "CPU:LTUH:PM01:POWEROFF3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM01:POWEROFFSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:PM01:POWERMSG PP")
#  field(DOL2, "0")                 
#  field(LNK2, "CPU:LTUH:PM01:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:PM01:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:PM01:POWERON") {
  field(DESC, "Power on system")            
  field(FLNK, "CPU:LTUH:PM01:POWERON1")
  field(PINI, "NO")             
}                                 
record(longout, "CPU:LTUH:PM01:POWERON1") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM01:POWERON2")
}  
record(longout, "CPU:LTUH:PM01:POWERON2") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:PM01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM01:POWERON3")
}  
record(calcout, "CPU:LTUH:PM01:POWERON3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM01:POWERONSEQ") {
#  field(SELM, "All")              
#  field(DOL1, "2")                 
#  field(LNK1, "CPU:LTUH:PM01:POWERMSG PP")
#  field(DOL2, "1")                
#  field(LNK2, "CPU:LTUH:PM01:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:PM01:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:PM01:HARDRESET") {
  field(DESC, "Power cycle system")            
  field(FLNK, "CPU:LTUH:PM01:HARDRESET1")
  field(PINI, "NO")
}                                   
record(longout, "CPU:LTUH:PM01:HARDRESET1") {     
  field(DESC, "Power off system")            
  field(DOL, "3")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM01:HARDRESET2")
}  
record(longout, "CPU:LTUH:PM01:HARDRESET2") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:PM01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM01:HARDRESET3")
}  
record(calcout, "CPU:LTUH:PM01:HARDRESET3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM01:HARDRESETSEQ") {
#  field(SELM, "All")                
#  field(DOL1, "3")                 
#  field(LNK1, "CPU:LTUH:PM01:POWERMSG PP")
#  field(DOL2, "2")                  
#  field(LNK2, "CPU:LTUH:PM01:POWERCTL PP") 
#  field(DLY3, "5")                 
#  field(DOL3, "0")                 
#  field(LNK3, "CPU:LTUH:PM01:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:PM01:SOFTSHUTDOWN") {     
  field(DESC, "Soft shutdown system")            
  field(FLNK, "CPU:LTUH:PM01:SOFTSHUTDOWN1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:PM01:SOFTSHUTDOWN1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM01:SOFTSHUTDOWN2")
}  
record(longout, "CPU:LTUH:PM01:SOFTSHUTDOWN2") {     
  field(DESC, "Power off system")            
  field(DOL, "5")
  field(OUT, "CPU:LTUH:PM01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM01:SOFTSHUTDOWN3")
}  
record(calcout, "CPU:LTUH:PM01:SOFTSHUTDOWN3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM01:SOFTSHUTDOWNSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:PM01:POWERMSG PP")
#  field(DOL2, "5")                 
#  field(LNK2, "CPU:LTUH:PM01:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:PM01:POWERMSG PP")
#}                                   

record(mbbo, "CPU:LTUH:PM01:POWERMSG") {
  field(ZRVL, "0")               
  field(ONVL, "1")               
  field(TWVL, "2")               
  field(THVL, "3")               
  field(ONST, "TURNING_OFF")     
  field(TWST, "TURNING_ON")      
  field(THST, "RESETTING")       
  field(ZRSV, "NO_ALARM")        
  field(ONSV, "MINOR")           
  field(TWSV, "MINOR")           
  field(THSV, "MINOR")           
  field(VAL, "0")                
  field(PINI, "YES")             
}                                

# Sends 'Chassis Power' IPMI command
# Vadatech MCH results are unreliable
# NAT MCH does not implement this command
# Dell Server and ATCA crates do seem to implement this
record(mbbo, "CPU:LTUH:PM01:POWERCTL") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-pm01+chas")
 field(ZRVL, "0")
 field(ZRST, "Power off")
 field(ONVL, "1")
 field(ONST, "Power on")
 field(THVL, "3")
 field(THST, "Hard reset")
# Soft shutdown required by PICMG 3.0
# Tested in ATCA, but not MicroTCA
 field(FVVL, "5")
 field(FVST, "Soft shutdown")
 field(VAL, "1")
}

# Peform IPMI 'Cold Reset'
record(bo, "CPU:LTUH:PM01:RESET") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-pm01+reset")
}

# Control sensor scan period [seconds]
# Default is 10 seconds
# Added this because PAL systems had 
# trouble at that rate
# Must match SENSOR_SCAN_PERIODS array 
# definition in devMch.c
record(mbbo, "CPU:LTUH:PM01:SENSOR_SCAN_PERIOD") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "5 seconds")
 field(ONVL, "1")
 field(ONST, "10 seconds")
 field(TWVL, "2")
 field(TWST, "20 seconds")
 field(THVL, "3")
 field(THST, "30 seconds")
 field(FRVL, "4")
 field(FRST, "60 seconds")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-pm01+scan")
 field(VAL,  "1")
 field(RVAL, "1")
 field(PINI, "YES")
 info(autosaveFields,"VAL RVAL")
}
# 24 bits assigned as follows:
# 0-7   power state byte (bit 7 ignored)
# 8-15  last power event byte (bits 5-7 ignored)
# 16-23 misc chassis state byte (bits 4-7 ignored)
record(longin, "CPU:LTUH:PM01:CHASSTAT") {
 field(DESC, "Chassis status")
 field(DTYP, "MCHsensor")
 field(SCAN, "5 second")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm01+chas")
 field(FLNK, "CPU:LTUH:PM01:POWERINFO_CALC")
}

record(calc, "CPU:LTUH:PM01:POWERINFO_CALC") {
 field(DESC, "Chassis power info")
 field(CALC, "A & 0x7F")
 field(INPA, "CPU:LTUH:PM01:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:PM01:POWERSTAT_CALC")
}

record(calc, "CPU:LTUH:PM01:POWERSTAT_CALC") {
 field(DESC, "Chassis power status")
 field(CALC, "A & 0x1F")
 field(INPA, "CPU:LTUH:PM01:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:PM01:POWERSTAT")
}

record(longin,"CPU:LTUH:PM01:POWERSTAT") {
  field(DESC, "Chassis power status")
  field(INP,  "CPU:LTUH:PM01:POWERSTAT_CALC MS")
  field(FLNK, "CPU:LTUH:PM01:POWERSTATE_CALC")
}

# Name POWERSTATE to be consistent with other 
# SLAC systems
record(calc,  "CPU:LTUH:PM01:POWERSTATE_CALC") {
  field(DESC, "Power on state")
  field(CALC, "A & 0x1")
  field(INPA, "CPU:LTUH:PM01:POWERSTAT MS")
  field(FLNK, "CPU:LTUH:PM01:POWERSTATE")
}

record(bi,    "CPU:LTUH:PM01:POWERSTATE") {
  field(DESC, "Power on state")
  field(INP,  "CPU:LTUH:PM01:POWERSTATE_CALC MS")
  field(ZNAM, "Not on")
  field(ZSV,  "MAJOR")
  field(ONAM, "On")
  field(OSV,  "NO_ALARM")
  field(FLNK, "CPU:LTUH:PM01:POWERPOLICY_CALC")
}

record(calc, "CPU:LTUH:PM01:POWERPOLICY_CALC") {
 field(DESC, "Chassis power policy")
 field(CALC, "(A & 0x60)>>5")
 field(INPA, "CPU:LTUH:PM01:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:PM01:POWERPOLICY")
}

record(mbbi,  "CPU:LTUH:PM01:POWERPOLICY") {
  field(DESC, "Chassis power policy")
  field(INP,  "CPU:LTUH:PM01:POWERPOLICY_CALC")
  field(ZRST, "Remains off")
  field(ZRVL, "0")
  field(ONST, "Previous state")
  field(ONVL, "1")
  field(TWST, "Powers up")
  field(TWVL, "2")
  field(THST, "Unknown")
  field(THVL, "3")
  field(FLNK, "CPU:LTUH:PM01:MISCSTAT_CALC")
}

record(calc, "CPU:LTUH:PM01:MISCSTAT_CALC") {
 field(DESC, "Chassis misc status")
 field(CALC, "(A & 0x0F0000)>>16")
 field(INPA, "CPU:LTUH:PM01:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:PM01:MISCSTAT")
}

record(longin, "CPU:LTUH:PM01:MISCSTAT") {
 field(DESC, "Chassis misc status")
 field(INP,  "CPU:LTUH:PM01:MISCSTAT_CALC MS")
 field(FLNK, "CPU:LTUH:PM01:LASTPOWER_CALC")
}

record(calc, "CPU:LTUH:PM01:LASTPOWER_CALC") {
 field(DESC, "Last power event")
 field(CALC, "(A & 0x1F00)>>8")
 field(INPA, "CPU:LTUH:PM01:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:PM01:LASTPOWER")
}

record(mbbi, "CPU:LTUH:PM01:LASTPOWER") {
 field(DESC, "Last power event")
 field(INP,  "CPU:LTUH:PM01:LASTPOWER_CALC MS")
 field(ZRST, "N/A")
 field(ZRVL, "0")
 field(ONST, "AC power failed")
 field(ONVL, "1")
 field(TWST, "Power overload")
 field(TWVL, "2")
 field(THST, "Power interlock")
 field(THVL, "4")
 field(FRST, "Power fault")
 field(FRVL, "8")
 field(FVST, "Remote power on")
 field(FVVL, "32") 
}
# Aliases are temporary for backward-compatibility

# FRU 'presence' record to indicate whether FRU
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FRU0:P") {
  field(DESC, "Module presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C0 N0 @cpu-ltuh-pm01+fpres")
  field(ZNAM, "Not present")
  field(ONAM, "Present")
  field(PINI, "YES")
  alias("CPU:LTUH:PM01:FRU0P")
}

# Vadatech 'hotswap' sensor, provides FRU M-state
record(mbbi, "CPU:LTUH:PM01:FRU0:MSTATE") {
  field(SCAN, "10 second")
#  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C240 N1 @cpu-ltuh-pm01+hs")
  field(ONVL, "0x01")
  field(ONST, "Not Installed")
  field(TWVL, "0x02")
  field(TWST, "Inactive")
  field(THVL, "0x04")
  field(THST, "Activation Request")
  field(FRVL, "0x08")
  field(FRST, "Activation In Progress")
  field(FVVL, "0x10")
  field(FVST, "Active")
  field(SXVL, "0x20")
  field(SXST, "Deactivation Request")
  field(SVVL, "0x40")
  field(SVST, "Deactivation In Progress")
  field(EIVL, "0x80")
  field(EIST, "Communication Lost")
  field(NIVL, "0x100")
  field(NIST, "Not Available")
  alias("CPU:LTUH:PM01:FRU0_MSTATE")
}

record(ai, "CPU:LTUH:PM01:FRU0:FRUID") {
  field(DESC, "Module type")
  field(VAL,  "0")
  field(PINI, "YES")
  alias("CPU:LTUH:PM01:FRU0_FRUID")
}

record(stringin, "CPU:LTUH:PM01:FRU0:BMANUF") {
  field(DESC, "Board manufacturer")
  field(SCAN, "I/O Intr")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+bmf")
  field(PINI, "YES")
  field(FLNK, "CPU:LTUH:PM01:FRU0:BPRODNAME")
  alias("CPU:LTUH:PM01:FRU0_BMANUF")
}

record(stringin, "CPU:LTUH:PM01:FRU0:BPRODNAME") {
  field(DESC, "Board product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+bp")
  field(FLNK, "CPU:LTUH:PM01:FRU0:BSN")
  alias("CPU:LTUH:PM01:FRU0_BPRODNAME")
}

record(stringin, "CPU:LTUH:PM01:FRU0:BSN") {
  field(DESC, "Board serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+bsn")
  field(FLNK, "CPU:LTUH:PM01:FRU0:BPARTNUMBER")
  alias("CPU:LTUH:PM01:FRU0_BSN")
}

record(stringin, "CPU:LTUH:PM01:FRU0:BPARTNUMBER") {
  field(DESC, "Board part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+bpn")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PMANUF")
  alias("CPU:LTUH:PM01:FRU0_BPARTNUMBER")
}

record(stringin, "CPU:LTUH:PM01:FRU0:PMANUF") {
  field(DESC, "Product manufacturer")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+pmf")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PPRODNAME")
  alias("CPU:LTUH:PM01:FRU0_PMANUF")
}

record(stringin, "CPU:LTUH:PM01:FRU0:PPRODNAME") {
  field(DESC, "Product product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+pp")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PSN")
  alias("CPU:LTUH:PM01:FRU0_PPRODNAME")
}

record(stringin, "CPU:LTUH:PM01:FRU0:PSN") {
  field(DESC, "Product serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+psn")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PPARTNUMBER")
  alias("CPU:LTUH:PM01:FRU0_PSN")
}

record(stringin, "CPU:LTUH:PM01:FRU0:PPARTNUMBER") {
  field(DESC, "Product part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+ppn")
  alias("CPU:LTUH:PM01:FRU0_PPARTNUMBER")
}

record(mbbo, "CPU:LTUH:PM01:FRU0:POWERCTL") {
  field(DESC, "Payload power control")
  field(DTYP, "MCHsensor")
  field(OMSL, "supervisory")
  field(OUT, "#B0 C0 N0  @cpu-ltuh-pm01+fru")
  field(ZRST, "Power off")
  field(ONST, "Power on")
#  reset not supported yet
#  field(TWST, "Hard reset")
  alias("CPU:LTUH:PM01:FRU0_POWERCTL")
}

record(ai, "CPU:LTUH:PM01:FRU0:PWR") {
  field(DESC, "Steady state power draw")
  field(SCAN, "10 second")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PWRDES")
  alias("CPU:LTUH:PM01:FRU0_PWR")
}

record(ai, "CPU:LTUH:PM01:FRU0:PWRDES") {
  field(DESC, "Desired steady state power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C1 N0  @cpu-ltuh-pm01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM01:FRU0:EPWR")
  alias("CPU:LTUH:PM01:FRU0_PWRDES")
}

record(ai, "CPU:LTUH:PM01:FRU0:EPWR") {
  field(DESC, "Early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C2 N0  @cpu-ltuh-pm01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM01:FRU0:EPWRDES")
  alias("CPU:LTUH:PM01:FRU0_EPWR")
}

record(ai, "CPU:LTUH:PM01:FRU0:EPWRDES") {
  field(DESC, "Desired early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C3 N0  @cpu-ltuh-pm01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PWRDLY")
  alias("CPU:LTUH:PM01:FRU0_EPWRDES")
}

record(ai, "CPU:LTUH:PM01:FRU0:PWRDLY") {
  field(DESC, "FRU delay to stable power")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C4 N0  @cpu-ltuh-pm01+pwr")
  field(EGU, "s")
  field(FLNK, "CPU:LTUH:PM01:FRU0:PWRDYN")
  alias("CPU:LTUH:PM01:FRU0_PWRDLY")
}

record(mbbi, "CPU:LTUH:PM01:FRU0:PWRDYN") {
  field(DESC, "FRU supports dynamic pwr reconfig")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C0 N0  @cpu-ltuh-pm01+pwr")
  field(ZRST, "No")
  field(ZRVL, "0")
  field(ONST, "Yes")
  field(ONVL, "1")
  alias("CPU:LTUH:PM01:FRU0_PWRDYN")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:TEMP20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:TEMP20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:TEMP20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:TEMP20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:V20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:V20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:V20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:V20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:I20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:I20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:I20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:I20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM01:FANSPEED12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-pm01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM01:FANSPEED12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM01:FANSPEED12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-pm01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM01:FANSPEED12P")
}
record(aSub, "CPU:LTUH:PM01:TYPE_SUB") {
  field(DESC, "Determine LCLS device type")
  field(SNAM, "subMchTypeFacility")
  field(PINI, "YES")
  field(FTA,  "DOUBLE")
  field(INPA, "CPU:LTUH:PM01:TYPE_RAW MS CP")
# B-H are 'type' values to be used by
# facility-specific software (in particular
# LCLS IOCManager)
# B is type value for Unknown device
  field(FTB,  "DOUBLE")
  field(INPB, "25")
# C is type value for Vadatech MCH
  field(FTC,  "DOUBLE")
  field(INPC, "26")
# D is type value for NAT MCH
  field(FTD,  "DOUBLE")
  field(INPD, "27")
# E is type value for Supermicro server
  field(FTE,  "DOUBLE")
  field(INPE, "28")
# F is type value for Pentair shelf manager
  field(FTF,  "DOUBLE")
  field(INPF, "30")
# G is type value for Artesyn shelf manager
  field(FTG,  "DOUBLE")
  field(INPG, "30")
# H is type value for Advantech server
  field(FTH,  "DOUBLE")
  field(INPH, "28")
# VALA is 'type' value used in LCLS IOCManager
  field(FTVA, "DOUBLE")
  field(FLNK, "CPU:LTUH:PM01:TYPE_DESC")
}

# Copy description to TYPE.DESC
record(stringout, "CPU:LTUH:PM01:TYPE_DESC") {
  field(OMSL, "closed_loop")
  field(DOL,  "CPU:LTUH:PM01:TYPE_RAW")
  field(OUT,  "CPU:LTUH:PM01:TYPE.DESC")
  field(FLNK, "CPU:LTUH:PM01:TYPE")
}

# DESC filled in by TYPE_DESC PV
record(ai, "CPU:LTUH:PM01:TYPE") {
  field(DESC, "")
  field(INP, "CPU:LTUH:PM01:TYPE_SUB.VALA")
}
record(mbbi, "CPU:LTUH:PM02:TYPE_RAW") {
 field(DESC, "Device type")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm02+mch")
 field(ZRST, "Unknown")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "MicroTCA")
 field(ONVL, "1")
 field(ONSV, "NO_ALARM")
 field(TWST, "MicroTCA")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Supermicro")
 field(THVL, "3")
 field(THSV, "NO_ALARM")
 field(FRST, "ATCA")
 field(FRVL, "4")
 field(FRSV, "NO_ALARM")
 field(FVVL, "5")
 field(FVST, "ATCA")
 field(FVSV, "NO_ALARM")
 field(SXVL, "6")
 field(SXST, "Advantech")
 field(SXSV, "NO_ALARM")
 field(PINI, "YES")
}

record(stringin, "CPU:LTUH:PM02:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-04")
  info(autosaveFields,"VAL")
}

# Control debug message verbosity
record(mbbo, "CPU:LTUH:PM02:DBG") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "Off")
 field(ONVL, "1")
 field(ONST, "Low")
 field(TWVL, "2")
 field(TWST, "Med")
 field(THVL, "3")
 field(THST, "High")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-pm02+dbg")
 field(VAL,  "0")
 field(PINI, "YES")
}

record(bi, "CPU:LTUH:PM02:ONLNSTAT") {
 field(DESC, "MCH online status")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm02+stat")
 field(ZNAM, "Offline")
 field(ZSV, "MAJOR")
 field(ONAM, "Online")
 field(OSV, "NO_ALARM")
 field(PINI, "YES")
 alias("CPU:LTUH:PM02:STAT")
}

record(mbbi, "CPU:LTUH:PM02:INIT") {
 field(DESC, "MCH comm initialized")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm02+init")
 field(ZRST, "Not initialized")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "Initializing...")
 field(ONVL, "1")
 field(ONSV, "MINOR")
 field(TWST, "Initialized")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Initialize failed")
 field(THVL, "3")
 field(THSV, "MAJOR")
 field(PINI, "YES")
}

record(bo, "CPU:LTUH:PM02:INITBYP") {
 field(DESC, "Override init for testing")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-pm02+init")
 field(ZNAM, "Not initialized")
 field(ZSV, "MAJOR")
 field(ONAM, "Initialized")
 field(OSV, "NO_ALARM")
 field(PINI, "NO")
}

record(bo, "CPU:LTUH:PM02:CONNECT") {
 field(DESC, "Enable comm with MCH")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-pm02+sess")
 field(ZNAM, "Disconnect")
 field(ZSV,  "MAJOR")
 field(ONAM, "Connect")
 field(OSV,  "NO_ALARM")
 field(VAL, "1")
 field(RVAL, "1")
 field(PINI, "YES") 
 info(autosaveFields,"VAL RVAL")
}

# Add power on, power off, hard-reset, and msg
# PVs to be consistent with other SLAC systems       
record(bo, "CPU:LTUH:PM02:POWEROFF") {     
  field(DESC, "Power off system")            
  field(FLNK, "CPU:LTUH:PM02:POWEROFF1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:PM02:POWEROFF1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM02:POWEROFF2")
}  
record(longout, "CPU:LTUH:PM02:POWEROFF2") {     
  field(DESC, "Power off system")            
  field(DOL, "0")
  field(OUT, "CPU:LTUH:PM02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM02:POWEROFF3")
}  
record(calcout, "CPU:LTUH:PM02:POWEROFF3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM02:POWEROFFSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:PM02:POWERMSG PP")
#  field(DOL2, "0")                 
#  field(LNK2, "CPU:LTUH:PM02:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:PM02:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:PM02:POWERON") {
  field(DESC, "Power on system")            
  field(FLNK, "CPU:LTUH:PM02:POWERON1")
  field(PINI, "NO")             
}                                 
record(longout, "CPU:LTUH:PM02:POWERON1") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM02:POWERON2")
}  
record(longout, "CPU:LTUH:PM02:POWERON2") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:PM02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM02:POWERON3")
}  
record(calcout, "CPU:LTUH:PM02:POWERON3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM02:POWERONSEQ") {
#  field(SELM, "All")              
#  field(DOL1, "2")                 
#  field(LNK1, "CPU:LTUH:PM02:POWERMSG PP")
#  field(DOL2, "1")                
#  field(LNK2, "CPU:LTUH:PM02:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:PM02:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:PM02:HARDRESET") {
  field(DESC, "Power cycle system")            
  field(FLNK, "CPU:LTUH:PM02:HARDRESET1")
  field(PINI, "NO")
}                                   
record(longout, "CPU:LTUH:PM02:HARDRESET1") {     
  field(DESC, "Power off system")            
  field(DOL, "3")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM02:HARDRESET2")
}  
record(longout, "CPU:LTUH:PM02:HARDRESET2") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:PM02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM02:HARDRESET3")
}  
record(calcout, "CPU:LTUH:PM02:HARDRESET3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM02:HARDRESETSEQ") {
#  field(SELM, "All")                
#  field(DOL1, "3")                 
#  field(LNK1, "CPU:LTUH:PM02:POWERMSG PP")
#  field(DOL2, "2")                  
#  field(LNK2, "CPU:LTUH:PM02:POWERCTL PP") 
#  field(DLY3, "5")                 
#  field(DOL3, "0")                 
#  field(LNK3, "CPU:LTUH:PM02:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:PM02:SOFTSHUTDOWN") {     
  field(DESC, "Soft shutdown system")            
  field(FLNK, "CPU:LTUH:PM02:SOFTSHUTDOWN1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:PM02:SOFTSHUTDOWN1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:PM02:SOFTSHUTDOWN2")
}  
record(longout, "CPU:LTUH:PM02:SOFTSHUTDOWN2") {     
  field(DESC, "Power off system")            
  field(DOL, "5")
  field(OUT, "CPU:LTUH:PM02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:PM02:SOFTSHUTDOWN3")
}  
record(calcout, "CPU:LTUH:PM02:SOFTSHUTDOWN3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:PM02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:PM02:SOFTSHUTDOWNSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:PM02:POWERMSG PP")
#  field(DOL2, "5")                 
#  field(LNK2, "CPU:LTUH:PM02:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:PM02:POWERMSG PP")
#}                                   

record(mbbo, "CPU:LTUH:PM02:POWERMSG") {
  field(ZRVL, "0")               
  field(ONVL, "1")               
  field(TWVL, "2")               
  field(THVL, "3")               
  field(ONST, "TURNING_OFF")     
  field(TWST, "TURNING_ON")      
  field(THST, "RESETTING")       
  field(ZRSV, "NO_ALARM")        
  field(ONSV, "MINOR")           
  field(TWSV, "MINOR")           
  field(THSV, "MINOR")           
  field(VAL, "0")                
  field(PINI, "YES")             
}                                

# Sends 'Chassis Power' IPMI command
# Vadatech MCH results are unreliable
# NAT MCH does not implement this command
# Dell Server and ATCA crates do seem to implement this
record(mbbo, "CPU:LTUH:PM02:POWERCTL") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-pm02+chas")
 field(ZRVL, "0")
 field(ZRST, "Power off")
 field(ONVL, "1")
 field(ONST, "Power on")
 field(THVL, "3")
 field(THST, "Hard reset")
# Soft shutdown required by PICMG 3.0
# Tested in ATCA, but not MicroTCA
 field(FVVL, "5")
 field(FVST, "Soft shutdown")
 field(VAL, "1")
}

# Peform IPMI 'Cold Reset'
record(bo, "CPU:LTUH:PM02:RESET") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-pm02+reset")
}

# Control sensor scan period [seconds]
# Default is 10 seconds
# Added this because PAL systems had 
# trouble at that rate
# Must match SENSOR_SCAN_PERIODS array 
# definition in devMch.c
record(mbbo, "CPU:LTUH:PM02:SENSOR_SCAN_PERIOD") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "5 seconds")
 field(ONVL, "1")
 field(ONST, "10 seconds")
 field(TWVL, "2")
 field(TWST, "20 seconds")
 field(THVL, "3")
 field(THST, "30 seconds")
 field(FRVL, "4")
 field(FRST, "60 seconds")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-pm02+scan")
 field(VAL,  "1")
 field(RVAL, "1")
 field(PINI, "YES")
 info(autosaveFields,"VAL RVAL")
}
# 24 bits assigned as follows:
# 0-7   power state byte (bit 7 ignored)
# 8-15  last power event byte (bits 5-7 ignored)
# 16-23 misc chassis state byte (bits 4-7 ignored)
record(longin, "CPU:LTUH:PM02:CHASSTAT") {
 field(DESC, "Chassis status")
 field(DTYP, "MCHsensor")
 field(SCAN, "5 second")
 field(INP, "#B0 C0 N0 @cpu-ltuh-pm02+chas")
 field(FLNK, "CPU:LTUH:PM02:POWERINFO_CALC")
}

record(calc, "CPU:LTUH:PM02:POWERINFO_CALC") {
 field(DESC, "Chassis power info")
 field(CALC, "A & 0x7F")
 field(INPA, "CPU:LTUH:PM02:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:PM02:POWERSTAT_CALC")
}

record(calc, "CPU:LTUH:PM02:POWERSTAT_CALC") {
 field(DESC, "Chassis power status")
 field(CALC, "A & 0x1F")
 field(INPA, "CPU:LTUH:PM02:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:PM02:POWERSTAT")
}

record(longin,"CPU:LTUH:PM02:POWERSTAT") {
  field(DESC, "Chassis power status")
  field(INP,  "CPU:LTUH:PM02:POWERSTAT_CALC MS")
  field(FLNK, "CPU:LTUH:PM02:POWERSTATE_CALC")
}

# Name POWERSTATE to be consistent with other 
# SLAC systems
record(calc,  "CPU:LTUH:PM02:POWERSTATE_CALC") {
  field(DESC, "Power on state")
  field(CALC, "A & 0x1")
  field(INPA, "CPU:LTUH:PM02:POWERSTAT MS")
  field(FLNK, "CPU:LTUH:PM02:POWERSTATE")
}

record(bi,    "CPU:LTUH:PM02:POWERSTATE") {
  field(DESC, "Power on state")
  field(INP,  "CPU:LTUH:PM02:POWERSTATE_CALC MS")
  field(ZNAM, "Not on")
  field(ZSV,  "MAJOR")
  field(ONAM, "On")
  field(OSV,  "NO_ALARM")
  field(FLNK, "CPU:LTUH:PM02:POWERPOLICY_CALC")
}

record(calc, "CPU:LTUH:PM02:POWERPOLICY_CALC") {
 field(DESC, "Chassis power policy")
 field(CALC, "(A & 0x60)>>5")
 field(INPA, "CPU:LTUH:PM02:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:PM02:POWERPOLICY")
}

record(mbbi,  "CPU:LTUH:PM02:POWERPOLICY") {
  field(DESC, "Chassis power policy")
  field(INP,  "CPU:LTUH:PM02:POWERPOLICY_CALC")
  field(ZRST, "Remains off")
  field(ZRVL, "0")
  field(ONST, "Previous state")
  field(ONVL, "1")
  field(TWST, "Powers up")
  field(TWVL, "2")
  field(THST, "Unknown")
  field(THVL, "3")
  field(FLNK, "CPU:LTUH:PM02:MISCSTAT_CALC")
}

record(calc, "CPU:LTUH:PM02:MISCSTAT_CALC") {
 field(DESC, "Chassis misc status")
 field(CALC, "(A & 0x0F0000)>>16")
 field(INPA, "CPU:LTUH:PM02:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:PM02:MISCSTAT")
}

record(longin, "CPU:LTUH:PM02:MISCSTAT") {
 field(DESC, "Chassis misc status")
 field(INP,  "CPU:LTUH:PM02:MISCSTAT_CALC MS")
 field(FLNK, "CPU:LTUH:PM02:LASTPOWER_CALC")
}

record(calc, "CPU:LTUH:PM02:LASTPOWER_CALC") {
 field(DESC, "Last power event")
 field(CALC, "(A & 0x1F00)>>8")
 field(INPA, "CPU:LTUH:PM02:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:PM02:LASTPOWER")
}

record(mbbi, "CPU:LTUH:PM02:LASTPOWER") {
 field(DESC, "Last power event")
 field(INP,  "CPU:LTUH:PM02:LASTPOWER_CALC MS")
 field(ZRST, "N/A")
 field(ZRVL, "0")
 field(ONST, "AC power failed")
 field(ONVL, "1")
 field(TWST, "Power overload")
 field(TWVL, "2")
 field(THST, "Power interlock")
 field(THVL, "4")
 field(FRST, "Power fault")
 field(FRVL, "8")
 field(FVST, "Remote power on")
 field(FVVL, "32") 
}
# Aliases are temporary for backward-compatibility

# FRU 'presence' record to indicate whether FRU
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FRU0:P") {
  field(DESC, "Module presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C0 N0 @cpu-ltuh-pm02+fpres")
  field(ZNAM, "Not present")
  field(ONAM, "Present")
  field(PINI, "YES")
  alias("CPU:LTUH:PM02:FRU0P")
}

# Vadatech 'hotswap' sensor, provides FRU M-state
record(mbbi, "CPU:LTUH:PM02:FRU0:MSTATE") {
  field(SCAN, "10 second")
#  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C240 N1 @cpu-ltuh-pm02+hs")
  field(ONVL, "0x01")
  field(ONST, "Not Installed")
  field(TWVL, "0x02")
  field(TWST, "Inactive")
  field(THVL, "0x04")
  field(THST, "Activation Request")
  field(FRVL, "0x08")
  field(FRST, "Activation In Progress")
  field(FVVL, "0x10")
  field(FVST, "Active")
  field(SXVL, "0x20")
  field(SXST, "Deactivation Request")
  field(SVVL, "0x40")
  field(SVST, "Deactivation In Progress")
  field(EIVL, "0x80")
  field(EIST, "Communication Lost")
  field(NIVL, "0x100")
  field(NIST, "Not Available")
  alias("CPU:LTUH:PM02:FRU0_MSTATE")
}

record(ai, "CPU:LTUH:PM02:FRU0:FRUID") {
  field(DESC, "Module type")
  field(VAL,  "0")
  field(PINI, "YES")
  alias("CPU:LTUH:PM02:FRU0_FRUID")
}

record(stringin, "CPU:LTUH:PM02:FRU0:BMANUF") {
  field(DESC, "Board manufacturer")
  field(SCAN, "I/O Intr")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+bmf")
  field(PINI, "YES")
  field(FLNK, "CPU:LTUH:PM02:FRU0:BPRODNAME")
  alias("CPU:LTUH:PM02:FRU0_BMANUF")
}

record(stringin, "CPU:LTUH:PM02:FRU0:BPRODNAME") {
  field(DESC, "Board product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+bp")
  field(FLNK, "CPU:LTUH:PM02:FRU0:BSN")
  alias("CPU:LTUH:PM02:FRU0_BPRODNAME")
}

record(stringin, "CPU:LTUH:PM02:FRU0:BSN") {
  field(DESC, "Board serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+bsn")
  field(FLNK, "CPU:LTUH:PM02:FRU0:BPARTNUMBER")
  alias("CPU:LTUH:PM02:FRU0_BSN")
}

record(stringin, "CPU:LTUH:PM02:FRU0:BPARTNUMBER") {
  field(DESC, "Board part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+bpn")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PMANUF")
  alias("CPU:LTUH:PM02:FRU0_BPARTNUMBER")
}

record(stringin, "CPU:LTUH:PM02:FRU0:PMANUF") {
  field(DESC, "Product manufacturer")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+pmf")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PPRODNAME")
  alias("CPU:LTUH:PM02:FRU0_PMANUF")
}

record(stringin, "CPU:LTUH:PM02:FRU0:PPRODNAME") {
  field(DESC, "Product product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+pp")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PSN")
  alias("CPU:LTUH:PM02:FRU0_PPRODNAME")
}

record(stringin, "CPU:LTUH:PM02:FRU0:PSN") {
  field(DESC, "Product serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+psn")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PPARTNUMBER")
  alias("CPU:LTUH:PM02:FRU0_PSN")
}

record(stringin, "CPU:LTUH:PM02:FRU0:PPARTNUMBER") {
  field(DESC, "Product part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+ppn")
  alias("CPU:LTUH:PM02:FRU0_PPARTNUMBER")
}

record(mbbo, "CPU:LTUH:PM02:FRU0:POWERCTL") {
  field(DESC, "Payload power control")
  field(DTYP, "MCHsensor")
  field(OMSL, "supervisory")
  field(OUT, "#B0 C0 N0  @cpu-ltuh-pm02+fru")
  field(ZRST, "Power off")
  field(ONST, "Power on")
#  reset not supported yet
#  field(TWST, "Hard reset")
  alias("CPU:LTUH:PM02:FRU0_POWERCTL")
}

record(ai, "CPU:LTUH:PM02:FRU0:PWR") {
  field(DESC, "Steady state power draw")
  field(SCAN, "10 second")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-pm02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PWRDES")
  alias("CPU:LTUH:PM02:FRU0_PWR")
}

record(ai, "CPU:LTUH:PM02:FRU0:PWRDES") {
  field(DESC, "Desired steady state power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C1 N0  @cpu-ltuh-pm02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM02:FRU0:EPWR")
  alias("CPU:LTUH:PM02:FRU0_PWRDES")
}

record(ai, "CPU:LTUH:PM02:FRU0:EPWR") {
  field(DESC, "Early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C2 N0  @cpu-ltuh-pm02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM02:FRU0:EPWRDES")
  alias("CPU:LTUH:PM02:FRU0_EPWR")
}

record(ai, "CPU:LTUH:PM02:FRU0:EPWRDES") {
  field(DESC, "Desired early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C3 N0  @cpu-ltuh-pm02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PWRDLY")
  alias("CPU:LTUH:PM02:FRU0_EPWRDES")
}

record(ai, "CPU:LTUH:PM02:FRU0:PWRDLY") {
  field(DESC, "FRU delay to stable power")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C4 N0  @cpu-ltuh-pm02+pwr")
  field(EGU, "s")
  field(FLNK, "CPU:LTUH:PM02:FRU0:PWRDYN")
  alias("CPU:LTUH:PM02:FRU0_PWRDLY")
}

record(mbbi, "CPU:LTUH:PM02:FRU0:PWRDYN") {
  field(DESC, "FRU supports dynamic pwr reconfig")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C0 N0  @cpu-ltuh-pm02+pwr")
  field(ZRST, "No")
  field(ZRVL, "0")
  field(ONST, "Yes")
  field(ONVL, "1")
  alias("CPU:LTUH:PM02:FRU0_PWRDYN")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:TEMP20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:TEMP20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:TEMP20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:TEMP20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:V20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:V20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:V20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:V20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:I20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:I20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:I20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:I20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:PM02:FANSPEED12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-pm02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:PM02:FANSPEED12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:PM02:FANSPEED12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-pm02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:PM02:FANSPEED12P")
}
record(aSub, "CPU:LTUH:PM02:TYPE_SUB") {
  field(DESC, "Determine LCLS device type")
  field(SNAM, "subMchTypeFacility")
  field(PINI, "YES")
  field(FTA,  "DOUBLE")
  field(INPA, "CPU:LTUH:PM02:TYPE_RAW MS CP")
# B-H are 'type' values to be used by
# facility-specific software (in particular
# LCLS IOCManager)
# B is type value for Unknown device
  field(FTB,  "DOUBLE")
  field(INPB, "25")
# C is type value for Vadatech MCH
  field(FTC,  "DOUBLE")
  field(INPC, "26")
# D is type value for NAT MCH
  field(FTD,  "DOUBLE")
  field(INPD, "27")
# E is type value for Supermicro server
  field(FTE,  "DOUBLE")
  field(INPE, "28")
# F is type value for Pentair shelf manager
  field(FTF,  "DOUBLE")
  field(INPF, "30")
# G is type value for Artesyn shelf manager
  field(FTG,  "DOUBLE")
  field(INPG, "30")
# H is type value for Advantech server
  field(FTH,  "DOUBLE")
  field(INPH, "28")
# VALA is 'type' value used in LCLS IOCManager
  field(FTVA, "DOUBLE")
  field(FLNK, "CPU:LTUH:PM02:TYPE_DESC")
}

# Copy description to TYPE.DESC
record(stringout, "CPU:LTUH:PM02:TYPE_DESC") {
  field(OMSL, "closed_loop")
  field(DOL,  "CPU:LTUH:PM02:TYPE_RAW")
  field(OUT,  "CPU:LTUH:PM02:TYPE.DESC")
  field(FLNK, "CPU:LTUH:PM02:TYPE")
}

# DESC filled in by TYPE_DESC PV
record(ai, "CPU:LTUH:PM02:TYPE") {
  field(DESC, "")
  field(INP, "CPU:LTUH:PM02:TYPE_SUB.VALA")
}
record(mbbi, "CPU:LTUH:SP01:TYPE_RAW") {
 field(DESC, "Device type")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp01+mch")
 field(ZRST, "Unknown")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "MicroTCA")
 field(ONVL, "1")
 field(ONSV, "NO_ALARM")
 field(TWST, "MicroTCA")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Supermicro")
 field(THVL, "3")
 field(THSV, "NO_ALARM")
 field(FRST, "ATCA")
 field(FRVL, "4")
 field(FRSV, "NO_ALARM")
 field(FVVL, "5")
 field(FVST, "ATCA")
 field(FVSV, "NO_ALARM")
 field(SXVL, "6")
 field(SXST, "Advantech")
 field(SXSV, "NO_ALARM")
 field(PINI, "YES")
}

record(stringin, "CPU:LTUH:SP01:LOC") {
  field(PINI, "YES")
  field(VAL, "B105-0141")
  info(autosaveFields,"VAL")
}

# Control debug message verbosity
record(mbbo, "CPU:LTUH:SP01:DBG") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "Off")
 field(ONVL, "1")
 field(ONST, "Low")
 field(TWVL, "2")
 field(TWST, "Med")
 field(THVL, "3")
 field(THST, "High")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp01+dbg")
 field(VAL,  "0")
 field(PINI, "YES")
}

record(bi, "CPU:LTUH:SP01:ONLNSTAT") {
 field(DESC, "MCH online status")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp01+stat")
 field(ZNAM, "Offline")
 field(ZSV, "MAJOR")
 field(ONAM, "Online")
 field(OSV, "NO_ALARM")
 field(PINI, "YES")
 alias("CPU:LTUH:SP01:STAT")
}

record(mbbi, "CPU:LTUH:SP01:INIT") {
 field(DESC, "MCH comm initialized")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp01+init")
 field(ZRST, "Not initialized")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "Initializing...")
 field(ONVL, "1")
 field(ONSV, "MINOR")
 field(TWST, "Initialized")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Initialize failed")
 field(THVL, "3")
 field(THSV, "MAJOR")
 field(PINI, "YES")
}

record(bo, "CPU:LTUH:SP01:INITBYP") {
 field(DESC, "Override init for testing")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp01+init")
 field(ZNAM, "Not initialized")
 field(ZSV, "MAJOR")
 field(ONAM, "Initialized")
 field(OSV, "NO_ALARM")
 field(PINI, "NO")
}

record(bo, "CPU:LTUH:SP01:CONNECT") {
 field(DESC, "Enable comm with MCH")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp01+sess")
 field(ZNAM, "Disconnect")
 field(ZSV,  "MAJOR")
 field(ONAM, "Connect")
 field(OSV,  "NO_ALARM")
 field(VAL, "1")
 field(RVAL, "1")
 field(PINI, "YES") 
 info(autosaveFields,"VAL RVAL")
}

# Add power on, power off, hard-reset, and msg
# PVs to be consistent with other SLAC systems       
record(bo, "CPU:LTUH:SP01:POWEROFF") {     
  field(DESC, "Power off system")            
  field(FLNK, "CPU:LTUH:SP01:POWEROFF1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:SP01:POWEROFF1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP01:POWEROFF2")
}  
record(longout, "CPU:LTUH:SP01:POWEROFF2") {     
  field(DESC, "Power off system")            
  field(DOL, "0")
  field(OUT, "CPU:LTUH:SP01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP01:POWEROFF3")
}  
record(calcout, "CPU:LTUH:SP01:POWEROFF3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP01:POWEROFFSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:SP01:POWERMSG PP")
#  field(DOL2, "0")                 
#  field(LNK2, "CPU:LTUH:SP01:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP01:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP01:POWERON") {
  field(DESC, "Power on system")            
  field(FLNK, "CPU:LTUH:SP01:POWERON1")
  field(PINI, "NO")             
}                                 
record(longout, "CPU:LTUH:SP01:POWERON1") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP01:POWERON2")
}  
record(longout, "CPU:LTUH:SP01:POWERON2") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP01:POWERON3")
}  
record(calcout, "CPU:LTUH:SP01:POWERON3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP01:POWERONSEQ") {
#  field(SELM, "All")              
#  field(DOL1, "2")                 
#  field(LNK1, "CPU:LTUH:SP01:POWERMSG PP")
#  field(DOL2, "1")                
#  field(LNK2, "CPU:LTUH:SP01:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP01:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP01:HARDRESET") {
  field(DESC, "Power cycle system")            
  field(FLNK, "CPU:LTUH:SP01:HARDRESET1")
  field(PINI, "NO")
}                                   
record(longout, "CPU:LTUH:SP01:HARDRESET1") {     
  field(DESC, "Power off system")            
  field(DOL, "3")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP01:HARDRESET2")
}  
record(longout, "CPU:LTUH:SP01:HARDRESET2") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:SP01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP01:HARDRESET3")
}  
record(calcout, "CPU:LTUH:SP01:HARDRESET3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP01:HARDRESETSEQ") {
#  field(SELM, "All")                
#  field(DOL1, "3")                 
#  field(LNK1, "CPU:LTUH:SP01:POWERMSG PP")
#  field(DOL2, "2")                  
#  field(LNK2, "CPU:LTUH:SP01:POWERCTL PP") 
#  field(DLY3, "5")                 
#  field(DOL3, "0")                 
#  field(LNK3, "CPU:LTUH:SP01:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP01:SOFTSHUTDOWN") {     
  field(DESC, "Soft shutdown system")            
  field(FLNK, "CPU:LTUH:SP01:SOFTSHUTDOWN1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:SP01:SOFTSHUTDOWN1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP01:SOFTSHUTDOWN2")
}  
record(longout, "CPU:LTUH:SP01:SOFTSHUTDOWN2") {     
  field(DESC, "Power off system")            
  field(DOL, "5")
  field(OUT, "CPU:LTUH:SP01:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP01:SOFTSHUTDOWN3")
}  
record(calcout, "CPU:LTUH:SP01:SOFTSHUTDOWN3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP01:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP01:SOFTSHUTDOWNSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:SP01:POWERMSG PP")
#  field(DOL2, "5")                 
#  field(LNK2, "CPU:LTUH:SP01:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP01:POWERMSG PP")
#}                                   

record(mbbo, "CPU:LTUH:SP01:POWERMSG") {
  field(ZRVL, "0")               
  field(ONVL, "1")               
  field(TWVL, "2")               
  field(THVL, "3")               
  field(ONST, "TURNING_OFF")     
  field(TWST, "TURNING_ON")      
  field(THST, "RESETTING")       
  field(ZRSV, "NO_ALARM")        
  field(ONSV, "MINOR")           
  field(TWSV, "MINOR")           
  field(THSV, "MINOR")           
  field(VAL, "0")                
  field(PINI, "YES")             
}                                

# Sends 'Chassis Power' IPMI command
# Vadatech MCH results are unreliable
# NAT MCH does not implement this command
# Dell Server and ATCA crates do seem to implement this
record(mbbo, "CPU:LTUH:SP01:POWERCTL") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp01+chas")
 field(ZRVL, "0")
 field(ZRST, "Power off")
 field(ONVL, "1")
 field(ONST, "Power on")
 field(THVL, "3")
 field(THST, "Hard reset")
# Soft shutdown required by PICMG 3.0
# Tested in ATCA, but not MicroTCA
 field(FVVL, "5")
 field(FVST, "Soft shutdown")
 field(VAL, "1")
}

# Peform IPMI 'Cold Reset'
record(bo, "CPU:LTUH:SP01:RESET") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp01+reset")
}

# Control sensor scan period [seconds]
# Default is 10 seconds
# Added this because PAL systems had 
# trouble at that rate
# Must match SENSOR_SCAN_PERIODS array 
# definition in devMch.c
record(mbbo, "CPU:LTUH:SP01:SENSOR_SCAN_PERIOD") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "5 seconds")
 field(ONVL, "1")
 field(ONST, "10 seconds")
 field(TWVL, "2")
 field(TWST, "20 seconds")
 field(THVL, "3")
 field(THST, "30 seconds")
 field(FRVL, "4")
 field(FRST, "60 seconds")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp01+scan")
 field(VAL,  "1")
 field(RVAL, "1")
 field(PINI, "YES")
 info(autosaveFields,"VAL RVAL")
}
# 24 bits assigned as follows:
# 0-7   power state byte (bit 7 ignored)
# 8-15  last power event byte (bits 5-7 ignored)
# 16-23 misc chassis state byte (bits 4-7 ignored)
record(longin, "CPU:LTUH:SP01:CHASSTAT") {
 field(DESC, "Chassis status")
 field(DTYP, "MCHsensor")
 field(SCAN, "5 second")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp01+chas")
 field(FLNK, "CPU:LTUH:SP01:POWERINFO_CALC")
}

record(calc, "CPU:LTUH:SP01:POWERINFO_CALC") {
 field(DESC, "Chassis power info")
 field(CALC, "A & 0x7F")
 field(INPA, "CPU:LTUH:SP01:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP01:POWERSTAT_CALC")
}

record(calc, "CPU:LTUH:SP01:POWERSTAT_CALC") {
 field(DESC, "Chassis power status")
 field(CALC, "A & 0x1F")
 field(INPA, "CPU:LTUH:SP01:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:SP01:POWERSTAT")
}

record(longin,"CPU:LTUH:SP01:POWERSTAT") {
  field(DESC, "Chassis power status")
  field(INP,  "CPU:LTUH:SP01:POWERSTAT_CALC MS")
  field(FLNK, "CPU:LTUH:SP01:POWERSTATE_CALC")
}

# Name POWERSTATE to be consistent with other 
# SLAC systems
record(calc,  "CPU:LTUH:SP01:POWERSTATE_CALC") {
  field(DESC, "Power on state")
  field(CALC, "A & 0x1")
  field(INPA, "CPU:LTUH:SP01:POWERSTAT MS")
  field(FLNK, "CPU:LTUH:SP01:POWERSTATE")
}

record(bi,    "CPU:LTUH:SP01:POWERSTATE") {
  field(DESC, "Power on state")
  field(INP,  "CPU:LTUH:SP01:POWERSTATE_CALC MS")
  field(ZNAM, "Not on")
  field(ZSV,  "MAJOR")
  field(ONAM, "On")
  field(OSV,  "NO_ALARM")
  field(FLNK, "CPU:LTUH:SP01:POWERPOLICY_CALC")
}

record(calc, "CPU:LTUH:SP01:POWERPOLICY_CALC") {
 field(DESC, "Chassis power policy")
 field(CALC, "(A & 0x60)>>5")
 field(INPA, "CPU:LTUH:SP01:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:SP01:POWERPOLICY")
}

record(mbbi,  "CPU:LTUH:SP01:POWERPOLICY") {
  field(DESC, "Chassis power policy")
  field(INP,  "CPU:LTUH:SP01:POWERPOLICY_CALC")
  field(ZRST, "Remains off")
  field(ZRVL, "0")
  field(ONST, "Previous state")
  field(ONVL, "1")
  field(TWST, "Powers up")
  field(TWVL, "2")
  field(THST, "Unknown")
  field(THVL, "3")
  field(FLNK, "CPU:LTUH:SP01:MISCSTAT_CALC")
}

record(calc, "CPU:LTUH:SP01:MISCSTAT_CALC") {
 field(DESC, "Chassis misc status")
 field(CALC, "(A & 0x0F0000)>>16")
 field(INPA, "CPU:LTUH:SP01:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP01:MISCSTAT")
}

record(longin, "CPU:LTUH:SP01:MISCSTAT") {
 field(DESC, "Chassis misc status")
 field(INP,  "CPU:LTUH:SP01:MISCSTAT_CALC MS")
 field(FLNK, "CPU:LTUH:SP01:LASTPOWER_CALC")
}

record(calc, "CPU:LTUH:SP01:LASTPOWER_CALC") {
 field(DESC, "Last power event")
 field(CALC, "(A & 0x1F00)>>8")
 field(INPA, "CPU:LTUH:SP01:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP01:LASTPOWER")
}

record(mbbi, "CPU:LTUH:SP01:LASTPOWER") {
 field(DESC, "Last power event")
 field(INP,  "CPU:LTUH:SP01:LASTPOWER_CALC MS")
 field(ZRST, "N/A")
 field(ZRVL, "0")
 field(ONST, "AC power failed")
 field(ONVL, "1")
 field(TWST, "Power overload")
 field(TWVL, "2")
 field(THST, "Power interlock")
 field(THVL, "4")
 field(FRST, "Power fault")
 field(FRVL, "8")
 field(FVST, "Remote power on")
 field(FVVL, "32") 
}
# Aliases are temporary for backward-compatibility

# FRU 'presence' record to indicate whether FRU
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FRU0:P") {
  field(DESC, "Module presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C0 N0 @cpu-ltuh-sp01+fpres")
  field(ZNAM, "Not present")
  field(ONAM, "Present")
  field(PINI, "YES")
  alias("CPU:LTUH:SP01:FRU0P")
}

# Vadatech 'hotswap' sensor, provides FRU M-state
record(mbbi, "CPU:LTUH:SP01:FRU0:MSTATE") {
  field(SCAN, "10 second")
#  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C240 N1 @cpu-ltuh-sp01+hs")
  field(ONVL, "0x01")
  field(ONST, "Not Installed")
  field(TWVL, "0x02")
  field(TWST, "Inactive")
  field(THVL, "0x04")
  field(THST, "Activation Request")
  field(FRVL, "0x08")
  field(FRST, "Activation In Progress")
  field(FVVL, "0x10")
  field(FVST, "Active")
  field(SXVL, "0x20")
  field(SXST, "Deactivation Request")
  field(SVVL, "0x40")
  field(SVST, "Deactivation In Progress")
  field(EIVL, "0x80")
  field(EIST, "Communication Lost")
  field(NIVL, "0x100")
  field(NIST, "Not Available")
  alias("CPU:LTUH:SP01:FRU0_MSTATE")
}

record(ai, "CPU:LTUH:SP01:FRU0:FRUID") {
  field(DESC, "Module type")
  field(VAL,  "0")
  field(PINI, "YES")
  alias("CPU:LTUH:SP01:FRU0_FRUID")
}

record(stringin, "CPU:LTUH:SP01:FRU0:BMANUF") {
  field(DESC, "Board manufacturer")
  field(SCAN, "I/O Intr")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+bmf")
  field(PINI, "YES")
  field(FLNK, "CPU:LTUH:SP01:FRU0:BPRODNAME")
  alias("CPU:LTUH:SP01:FRU0_BMANUF")
}

record(stringin, "CPU:LTUH:SP01:FRU0:BPRODNAME") {
  field(DESC, "Board product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+bp")
  field(FLNK, "CPU:LTUH:SP01:FRU0:BSN")
  alias("CPU:LTUH:SP01:FRU0_BPRODNAME")
}

record(stringin, "CPU:LTUH:SP01:FRU0:BSN") {
  field(DESC, "Board serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+bsn")
  field(FLNK, "CPU:LTUH:SP01:FRU0:BPARTNUMBER")
  alias("CPU:LTUH:SP01:FRU0_BSN")
}

record(stringin, "CPU:LTUH:SP01:FRU0:BPARTNUMBER") {
  field(DESC, "Board part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+bpn")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PMANUF")
  alias("CPU:LTUH:SP01:FRU0_BPARTNUMBER")
}

record(stringin, "CPU:LTUH:SP01:FRU0:PMANUF") {
  field(DESC, "Product manufacturer")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+pmf")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PPRODNAME")
  alias("CPU:LTUH:SP01:FRU0_PMANUF")
}

record(stringin, "CPU:LTUH:SP01:FRU0:PPRODNAME") {
  field(DESC, "Product product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+pp")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PSN")
  alias("CPU:LTUH:SP01:FRU0_PPRODNAME")
}

record(stringin, "CPU:LTUH:SP01:FRU0:PSN") {
  field(DESC, "Product serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+psn")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PPARTNUMBER")
  alias("CPU:LTUH:SP01:FRU0_PSN")
}

record(stringin, "CPU:LTUH:SP01:FRU0:PPARTNUMBER") {
  field(DESC, "Product part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+ppn")
  alias("CPU:LTUH:SP01:FRU0_PPARTNUMBER")
}

record(mbbo, "CPU:LTUH:SP01:FRU0:POWERCTL") {
  field(DESC, "Payload power control")
  field(DTYP, "MCHsensor")
  field(OMSL, "supervisory")
  field(OUT, "#B0 C0 N0  @cpu-ltuh-sp01+fru")
  field(ZRST, "Power off")
  field(ONST, "Power on")
#  reset not supported yet
#  field(TWST, "Hard reset")
  alias("CPU:LTUH:SP01:FRU0_POWERCTL")
}

record(ai, "CPU:LTUH:SP01:FRU0:PWR") {
  field(DESC, "Steady state power draw")
  field(SCAN, "10 second")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PWRDES")
  alias("CPU:LTUH:SP01:FRU0_PWR")
}

record(ai, "CPU:LTUH:SP01:FRU0:PWRDES") {
  field(DESC, "Desired steady state power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C1 N0  @cpu-ltuh-sp01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP01:FRU0:EPWR")
  alias("CPU:LTUH:SP01:FRU0_PWRDES")
}

record(ai, "CPU:LTUH:SP01:FRU0:EPWR") {
  field(DESC, "Early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C2 N0  @cpu-ltuh-sp01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP01:FRU0:EPWRDES")
  alias("CPU:LTUH:SP01:FRU0_EPWR")
}

record(ai, "CPU:LTUH:SP01:FRU0:EPWRDES") {
  field(DESC, "Desired early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C3 N0  @cpu-ltuh-sp01+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PWRDLY")
  alias("CPU:LTUH:SP01:FRU0_EPWRDES")
}

record(ai, "CPU:LTUH:SP01:FRU0:PWRDLY") {
  field(DESC, "FRU delay to stable power")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C4 N0  @cpu-ltuh-sp01+pwr")
  field(EGU, "s")
  field(FLNK, "CPU:LTUH:SP01:FRU0:PWRDYN")
  alias("CPU:LTUH:SP01:FRU0_PWRDLY")
}

record(mbbi, "CPU:LTUH:SP01:FRU0:PWRDYN") {
  field(DESC, "FRU supports dynamic pwr reconfig")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C0 N0  @cpu-ltuh-sp01+pwr")
  field(ZRST, "No")
  field(ZRVL, "0")
  field(ONST, "Yes")
  field(ONVL, "1")
  alias("CPU:LTUH:SP01:FRU0_PWRDYN")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:TEMP20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:TEMP20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:TEMP20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:TEMP20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:V20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:V20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:V20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:V20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:I20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:I20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:I20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:I20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP01:FANSPEED12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-sp01+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP01:FANSPEED12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP01:FANSPEED12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-sp01+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP01:FANSPEED12P")
}
record(aSub, "CPU:LTUH:SP01:TYPE_SUB") {
  field(DESC, "Determine LCLS device type")
  field(SNAM, "subMchTypeFacility")
  field(PINI, "YES")
  field(FTA,  "DOUBLE")
  field(INPA, "CPU:LTUH:SP01:TYPE_RAW MS CP")
# B-H are 'type' values to be used by
# facility-specific software (in particular
# LCLS IOCManager)
# B is type value for Unknown device
  field(FTB,  "DOUBLE")
  field(INPB, "25")
# C is type value for Vadatech MCH
  field(FTC,  "DOUBLE")
  field(INPC, "26")
# D is type value for NAT MCH
  field(FTD,  "DOUBLE")
  field(INPD, "27")
# E is type value for Supermicro server
  field(FTE,  "DOUBLE")
  field(INPE, "28")
# F is type value for Pentair shelf manager
  field(FTF,  "DOUBLE")
  field(INPF, "30")
# G is type value for Artesyn shelf manager
  field(FTG,  "DOUBLE")
  field(INPG, "30")
# H is type value for Advantech server
  field(FTH,  "DOUBLE")
  field(INPH, "28")
# VALA is 'type' value used in LCLS IOCManager
  field(FTVA, "DOUBLE")
  field(FLNK, "CPU:LTUH:SP01:TYPE_DESC")
}

# Copy description to TYPE.DESC
record(stringout, "CPU:LTUH:SP01:TYPE_DESC") {
  field(OMSL, "closed_loop")
  field(DOL,  "CPU:LTUH:SP01:TYPE_RAW")
  field(OUT,  "CPU:LTUH:SP01:TYPE.DESC")
  field(FLNK, "CPU:LTUH:SP01:TYPE")
}

# DESC filled in by TYPE_DESC PV
record(ai, "CPU:LTUH:SP01:TYPE") {
  field(DESC, "")
  field(INP, "CPU:LTUH:SP01:TYPE_SUB.VALA")
}
record(mbbi, "CPU:LTUH:SP02:TYPE_RAW") {
 field(DESC, "Device type")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp02+mch")
 field(ZRST, "Unknown")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "MicroTCA")
 field(ONVL, "1")
 field(ONSV, "NO_ALARM")
 field(TWST, "MicroTCA")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Supermicro")
 field(THVL, "3")
 field(THSV, "NO_ALARM")
 field(FRST, "ATCA")
 field(FRVL, "4")
 field(FRSV, "NO_ALARM")
 field(FVVL, "5")
 field(FVST, "ATCA")
 field(FVSV, "NO_ALARM")
 field(SXVL, "6")
 field(SXST, "Advantech")
 field(SXSV, "NO_ALARM")
 field(PINI, "YES")
}

record(stringin, "CPU:LTUH:SP02:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0641")
  info(autosaveFields,"VAL")
}

# Control debug message verbosity
record(mbbo, "CPU:LTUH:SP02:DBG") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "Off")
 field(ONVL, "1")
 field(ONST, "Low")
 field(TWVL, "2")
 field(TWST, "Med")
 field(THVL, "3")
 field(THST, "High")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp02+dbg")
 field(VAL,  "0")
 field(PINI, "YES")
}

record(bi, "CPU:LTUH:SP02:ONLNSTAT") {
 field(DESC, "MCH online status")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp02+stat")
 field(ZNAM, "Offline")
 field(ZSV, "MAJOR")
 field(ONAM, "Online")
 field(OSV, "NO_ALARM")
 field(PINI, "YES")
 alias("CPU:LTUH:SP02:STAT")
}

record(mbbi, "CPU:LTUH:SP02:INIT") {
 field(DESC, "MCH comm initialized")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp02+init")
 field(ZRST, "Not initialized")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "Initializing...")
 field(ONVL, "1")
 field(ONSV, "MINOR")
 field(TWST, "Initialized")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Initialize failed")
 field(THVL, "3")
 field(THSV, "MAJOR")
 field(PINI, "YES")
}

record(bo, "CPU:LTUH:SP02:INITBYP") {
 field(DESC, "Override init for testing")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp02+init")
 field(ZNAM, "Not initialized")
 field(ZSV, "MAJOR")
 field(ONAM, "Initialized")
 field(OSV, "NO_ALARM")
 field(PINI, "NO")
}

record(bo, "CPU:LTUH:SP02:CONNECT") {
 field(DESC, "Enable comm with MCH")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp02+sess")
 field(ZNAM, "Disconnect")
 field(ZSV,  "MAJOR")
 field(ONAM, "Connect")
 field(OSV,  "NO_ALARM")
 field(VAL, "1")
 field(RVAL, "1")
 field(PINI, "YES") 
 info(autosaveFields,"VAL RVAL")
}

# Add power on, power off, hard-reset, and msg
# PVs to be consistent with other SLAC systems       
record(bo, "CPU:LTUH:SP02:POWEROFF") {     
  field(DESC, "Power off system")            
  field(FLNK, "CPU:LTUH:SP02:POWEROFF1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:SP02:POWEROFF1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP02:POWEROFF2")
}  
record(longout, "CPU:LTUH:SP02:POWEROFF2") {     
  field(DESC, "Power off system")            
  field(DOL, "0")
  field(OUT, "CPU:LTUH:SP02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP02:POWEROFF3")
}  
record(calcout, "CPU:LTUH:SP02:POWEROFF3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP02:POWEROFFSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:SP02:POWERMSG PP")
#  field(DOL2, "0")                 
#  field(LNK2, "CPU:LTUH:SP02:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP02:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP02:POWERON") {
  field(DESC, "Power on system")            
  field(FLNK, "CPU:LTUH:SP02:POWERON1")
  field(PINI, "NO")             
}                                 
record(longout, "CPU:LTUH:SP02:POWERON1") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP02:POWERON2")
}  
record(longout, "CPU:LTUH:SP02:POWERON2") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP02:POWERON3")
}  
record(calcout, "CPU:LTUH:SP02:POWERON3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP02:POWERONSEQ") {
#  field(SELM, "All")              
#  field(DOL1, "2")                 
#  field(LNK1, "CPU:LTUH:SP02:POWERMSG PP")
#  field(DOL2, "1")                
#  field(LNK2, "CPU:LTUH:SP02:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP02:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP02:HARDRESET") {
  field(DESC, "Power cycle system")            
  field(FLNK, "CPU:LTUH:SP02:HARDRESET1")
  field(PINI, "NO")
}                                   
record(longout, "CPU:LTUH:SP02:HARDRESET1") {     
  field(DESC, "Power off system")            
  field(DOL, "3")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP02:HARDRESET2")
}  
record(longout, "CPU:LTUH:SP02:HARDRESET2") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:SP02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP02:HARDRESET3")
}  
record(calcout, "CPU:LTUH:SP02:HARDRESET3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP02:HARDRESETSEQ") {
#  field(SELM, "All")                
#  field(DOL1, "3")                 
#  field(LNK1, "CPU:LTUH:SP02:POWERMSG PP")
#  field(DOL2, "2")                  
#  field(LNK2, "CPU:LTUH:SP02:POWERCTL PP") 
#  field(DLY3, "5")                 
#  field(DOL3, "0")                 
#  field(LNK3, "CPU:LTUH:SP02:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP02:SOFTSHUTDOWN") {     
  field(DESC, "Soft shutdown system")            
  field(FLNK, "CPU:LTUH:SP02:SOFTSHUTDOWN1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:SP02:SOFTSHUTDOWN1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP02:SOFTSHUTDOWN2")
}  
record(longout, "CPU:LTUH:SP02:SOFTSHUTDOWN2") {     
  field(DESC, "Power off system")            
  field(DOL, "5")
  field(OUT, "CPU:LTUH:SP02:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP02:SOFTSHUTDOWN3")
}  
record(calcout, "CPU:LTUH:SP02:SOFTSHUTDOWN3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP02:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP02:SOFTSHUTDOWNSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:SP02:POWERMSG PP")
#  field(DOL2, "5")                 
#  field(LNK2, "CPU:LTUH:SP02:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP02:POWERMSG PP")
#}                                   

record(mbbo, "CPU:LTUH:SP02:POWERMSG") {
  field(ZRVL, "0")               
  field(ONVL, "1")               
  field(TWVL, "2")               
  field(THVL, "3")               
  field(ONST, "TURNING_OFF")     
  field(TWST, "TURNING_ON")      
  field(THST, "RESETTING")       
  field(ZRSV, "NO_ALARM")        
  field(ONSV, "MINOR")           
  field(TWSV, "MINOR")           
  field(THSV, "MINOR")           
  field(VAL, "0")                
  field(PINI, "YES")             
}                                

# Sends 'Chassis Power' IPMI command
# Vadatech MCH results are unreliable
# NAT MCH does not implement this command
# Dell Server and ATCA crates do seem to implement this
record(mbbo, "CPU:LTUH:SP02:POWERCTL") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp02+chas")
 field(ZRVL, "0")
 field(ZRST, "Power off")
 field(ONVL, "1")
 field(ONST, "Power on")
 field(THVL, "3")
 field(THST, "Hard reset")
# Soft shutdown required by PICMG 3.0
# Tested in ATCA, but not MicroTCA
 field(FVVL, "5")
 field(FVST, "Soft shutdown")
 field(VAL, "1")
}

# Peform IPMI 'Cold Reset'
record(bo, "CPU:LTUH:SP02:RESET") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp02+reset")
}

# Control sensor scan period [seconds]
# Default is 10 seconds
# Added this because PAL systems had 
# trouble at that rate
# Must match SENSOR_SCAN_PERIODS array 
# definition in devMch.c
record(mbbo, "CPU:LTUH:SP02:SENSOR_SCAN_PERIOD") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "5 seconds")
 field(ONVL, "1")
 field(ONST, "10 seconds")
 field(TWVL, "2")
 field(TWST, "20 seconds")
 field(THVL, "3")
 field(THST, "30 seconds")
 field(FRVL, "4")
 field(FRST, "60 seconds")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp02+scan")
 field(VAL,  "1")
 field(RVAL, "1")
 field(PINI, "YES")
 info(autosaveFields,"VAL RVAL")
}
# 24 bits assigned as follows:
# 0-7   power state byte (bit 7 ignored)
# 8-15  last power event byte (bits 5-7 ignored)
# 16-23 misc chassis state byte (bits 4-7 ignored)
record(longin, "CPU:LTUH:SP02:CHASSTAT") {
 field(DESC, "Chassis status")
 field(DTYP, "MCHsensor")
 field(SCAN, "5 second")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp02+chas")
 field(FLNK, "CPU:LTUH:SP02:POWERINFO_CALC")
}

record(calc, "CPU:LTUH:SP02:POWERINFO_CALC") {
 field(DESC, "Chassis power info")
 field(CALC, "A & 0x7F")
 field(INPA, "CPU:LTUH:SP02:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP02:POWERSTAT_CALC")
}

record(calc, "CPU:LTUH:SP02:POWERSTAT_CALC") {
 field(DESC, "Chassis power status")
 field(CALC, "A & 0x1F")
 field(INPA, "CPU:LTUH:SP02:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:SP02:POWERSTAT")
}

record(longin,"CPU:LTUH:SP02:POWERSTAT") {
  field(DESC, "Chassis power status")
  field(INP,  "CPU:LTUH:SP02:POWERSTAT_CALC MS")
  field(FLNK, "CPU:LTUH:SP02:POWERSTATE_CALC")
}

# Name POWERSTATE to be consistent with other 
# SLAC systems
record(calc,  "CPU:LTUH:SP02:POWERSTATE_CALC") {
  field(DESC, "Power on state")
  field(CALC, "A & 0x1")
  field(INPA, "CPU:LTUH:SP02:POWERSTAT MS")
  field(FLNK, "CPU:LTUH:SP02:POWERSTATE")
}

record(bi,    "CPU:LTUH:SP02:POWERSTATE") {
  field(DESC, "Power on state")
  field(INP,  "CPU:LTUH:SP02:POWERSTATE_CALC MS")
  field(ZNAM, "Not on")
  field(ZSV,  "MAJOR")
  field(ONAM, "On")
  field(OSV,  "NO_ALARM")
  field(FLNK, "CPU:LTUH:SP02:POWERPOLICY_CALC")
}

record(calc, "CPU:LTUH:SP02:POWERPOLICY_CALC") {
 field(DESC, "Chassis power policy")
 field(CALC, "(A & 0x60)>>5")
 field(INPA, "CPU:LTUH:SP02:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:SP02:POWERPOLICY")
}

record(mbbi,  "CPU:LTUH:SP02:POWERPOLICY") {
  field(DESC, "Chassis power policy")
  field(INP,  "CPU:LTUH:SP02:POWERPOLICY_CALC")
  field(ZRST, "Remains off")
  field(ZRVL, "0")
  field(ONST, "Previous state")
  field(ONVL, "1")
  field(TWST, "Powers up")
  field(TWVL, "2")
  field(THST, "Unknown")
  field(THVL, "3")
  field(FLNK, "CPU:LTUH:SP02:MISCSTAT_CALC")
}

record(calc, "CPU:LTUH:SP02:MISCSTAT_CALC") {
 field(DESC, "Chassis misc status")
 field(CALC, "(A & 0x0F0000)>>16")
 field(INPA, "CPU:LTUH:SP02:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP02:MISCSTAT")
}

record(longin, "CPU:LTUH:SP02:MISCSTAT") {
 field(DESC, "Chassis misc status")
 field(INP,  "CPU:LTUH:SP02:MISCSTAT_CALC MS")
 field(FLNK, "CPU:LTUH:SP02:LASTPOWER_CALC")
}

record(calc, "CPU:LTUH:SP02:LASTPOWER_CALC") {
 field(DESC, "Last power event")
 field(CALC, "(A & 0x1F00)>>8")
 field(INPA, "CPU:LTUH:SP02:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP02:LASTPOWER")
}

record(mbbi, "CPU:LTUH:SP02:LASTPOWER") {
 field(DESC, "Last power event")
 field(INP,  "CPU:LTUH:SP02:LASTPOWER_CALC MS")
 field(ZRST, "N/A")
 field(ZRVL, "0")
 field(ONST, "AC power failed")
 field(ONVL, "1")
 field(TWST, "Power overload")
 field(TWVL, "2")
 field(THST, "Power interlock")
 field(THVL, "4")
 field(FRST, "Power fault")
 field(FRVL, "8")
 field(FVST, "Remote power on")
 field(FVVL, "32") 
}
# Aliases are temporary for backward-compatibility

# FRU 'presence' record to indicate whether FRU
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FRU0:P") {
  field(DESC, "Module presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C0 N0 @cpu-ltuh-sp02+fpres")
  field(ZNAM, "Not present")
  field(ONAM, "Present")
  field(PINI, "YES")
  alias("CPU:LTUH:SP02:FRU0P")
}

# Vadatech 'hotswap' sensor, provides FRU M-state
record(mbbi, "CPU:LTUH:SP02:FRU0:MSTATE") {
  field(SCAN, "10 second")
#  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C240 N1 @cpu-ltuh-sp02+hs")
  field(ONVL, "0x01")
  field(ONST, "Not Installed")
  field(TWVL, "0x02")
  field(TWST, "Inactive")
  field(THVL, "0x04")
  field(THST, "Activation Request")
  field(FRVL, "0x08")
  field(FRST, "Activation In Progress")
  field(FVVL, "0x10")
  field(FVST, "Active")
  field(SXVL, "0x20")
  field(SXST, "Deactivation Request")
  field(SVVL, "0x40")
  field(SVST, "Deactivation In Progress")
  field(EIVL, "0x80")
  field(EIST, "Communication Lost")
  field(NIVL, "0x100")
  field(NIST, "Not Available")
  alias("CPU:LTUH:SP02:FRU0_MSTATE")
}

record(ai, "CPU:LTUH:SP02:FRU0:FRUID") {
  field(DESC, "Module type")
  field(VAL,  "0")
  field(PINI, "YES")
  alias("CPU:LTUH:SP02:FRU0_FRUID")
}

record(stringin, "CPU:LTUH:SP02:FRU0:BMANUF") {
  field(DESC, "Board manufacturer")
  field(SCAN, "I/O Intr")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+bmf")
  field(PINI, "YES")
  field(FLNK, "CPU:LTUH:SP02:FRU0:BPRODNAME")
  alias("CPU:LTUH:SP02:FRU0_BMANUF")
}

record(stringin, "CPU:LTUH:SP02:FRU0:BPRODNAME") {
  field(DESC, "Board product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+bp")
  field(FLNK, "CPU:LTUH:SP02:FRU0:BSN")
  alias("CPU:LTUH:SP02:FRU0_BPRODNAME")
}

record(stringin, "CPU:LTUH:SP02:FRU0:BSN") {
  field(DESC, "Board serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+bsn")
  field(FLNK, "CPU:LTUH:SP02:FRU0:BPARTNUMBER")
  alias("CPU:LTUH:SP02:FRU0_BSN")
}

record(stringin, "CPU:LTUH:SP02:FRU0:BPARTNUMBER") {
  field(DESC, "Board part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+bpn")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PMANUF")
  alias("CPU:LTUH:SP02:FRU0_BPARTNUMBER")
}

record(stringin, "CPU:LTUH:SP02:FRU0:PMANUF") {
  field(DESC, "Product manufacturer")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+pmf")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PPRODNAME")
  alias("CPU:LTUH:SP02:FRU0_PMANUF")
}

record(stringin, "CPU:LTUH:SP02:FRU0:PPRODNAME") {
  field(DESC, "Product product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+pp")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PSN")
  alias("CPU:LTUH:SP02:FRU0_PPRODNAME")
}

record(stringin, "CPU:LTUH:SP02:FRU0:PSN") {
  field(DESC, "Product serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+psn")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PPARTNUMBER")
  alias("CPU:LTUH:SP02:FRU0_PSN")
}

record(stringin, "CPU:LTUH:SP02:FRU0:PPARTNUMBER") {
  field(DESC, "Product part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+ppn")
  alias("CPU:LTUH:SP02:FRU0_PPARTNUMBER")
}

record(mbbo, "CPU:LTUH:SP02:FRU0:POWERCTL") {
  field(DESC, "Payload power control")
  field(DTYP, "MCHsensor")
  field(OMSL, "supervisory")
  field(OUT, "#B0 C0 N0  @cpu-ltuh-sp02+fru")
  field(ZRST, "Power off")
  field(ONST, "Power on")
#  reset not supported yet
#  field(TWST, "Hard reset")
  alias("CPU:LTUH:SP02:FRU0_POWERCTL")
}

record(ai, "CPU:LTUH:SP02:FRU0:PWR") {
  field(DESC, "Steady state power draw")
  field(SCAN, "10 second")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PWRDES")
  alias("CPU:LTUH:SP02:FRU0_PWR")
}

record(ai, "CPU:LTUH:SP02:FRU0:PWRDES") {
  field(DESC, "Desired steady state power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C1 N0  @cpu-ltuh-sp02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP02:FRU0:EPWR")
  alias("CPU:LTUH:SP02:FRU0_PWRDES")
}

record(ai, "CPU:LTUH:SP02:FRU0:EPWR") {
  field(DESC, "Early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C2 N0  @cpu-ltuh-sp02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP02:FRU0:EPWRDES")
  alias("CPU:LTUH:SP02:FRU0_EPWR")
}

record(ai, "CPU:LTUH:SP02:FRU0:EPWRDES") {
  field(DESC, "Desired early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C3 N0  @cpu-ltuh-sp02+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PWRDLY")
  alias("CPU:LTUH:SP02:FRU0_EPWRDES")
}

record(ai, "CPU:LTUH:SP02:FRU0:PWRDLY") {
  field(DESC, "FRU delay to stable power")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C4 N0  @cpu-ltuh-sp02+pwr")
  field(EGU, "s")
  field(FLNK, "CPU:LTUH:SP02:FRU0:PWRDYN")
  alias("CPU:LTUH:SP02:FRU0_PWRDLY")
}

record(mbbi, "CPU:LTUH:SP02:FRU0:PWRDYN") {
  field(DESC, "FRU supports dynamic pwr reconfig")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C0 N0  @cpu-ltuh-sp02+pwr")
  field(ZRST, "No")
  field(ZRVL, "0")
  field(ONST, "Yes")
  field(ONVL, "1")
  alias("CPU:LTUH:SP02:FRU0_PWRDYN")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:TEMP20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:TEMP20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:TEMP20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:TEMP20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:V20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:V20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:V20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:V20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:I20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:I20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:I20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:I20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP02:FANSPEED12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-sp02+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP02:FANSPEED12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP02:FANSPEED12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-sp02+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP02:FANSPEED12P")
}
record(aSub, "CPU:LTUH:SP02:TYPE_SUB") {
  field(DESC, "Determine LCLS device type")
  field(SNAM, "subMchTypeFacility")
  field(PINI, "YES")
  field(FTA,  "DOUBLE")
  field(INPA, "CPU:LTUH:SP02:TYPE_RAW MS CP")
# B-H are 'type' values to be used by
# facility-specific software (in particular
# LCLS IOCManager)
# B is type value for Unknown device
  field(FTB,  "DOUBLE")
  field(INPB, "25")
# C is type value for Vadatech MCH
  field(FTC,  "DOUBLE")
  field(INPC, "26")
# D is type value for NAT MCH
  field(FTD,  "DOUBLE")
  field(INPD, "27")
# E is type value for Supermicro server
  field(FTE,  "DOUBLE")
  field(INPE, "28")
# F is type value for Pentair shelf manager
  field(FTF,  "DOUBLE")
  field(INPF, "30")
# G is type value for Artesyn shelf manager
  field(FTG,  "DOUBLE")
  field(INPG, "30")
# H is type value for Advantech server
  field(FTH,  "DOUBLE")
  field(INPH, "28")
# VALA is 'type' value used in LCLS IOCManager
  field(FTVA, "DOUBLE")
  field(FLNK, "CPU:LTUH:SP02:TYPE_DESC")
}

# Copy description to TYPE.DESC
record(stringout, "CPU:LTUH:SP02:TYPE_DESC") {
  field(OMSL, "closed_loop")
  field(DOL,  "CPU:LTUH:SP02:TYPE_RAW")
  field(OUT,  "CPU:LTUH:SP02:TYPE.DESC")
  field(FLNK, "CPU:LTUH:SP02:TYPE")
}

# DESC filled in by TYPE_DESC PV
record(ai, "CPU:LTUH:SP02:TYPE") {
  field(DESC, "")
  field(INP, "CPU:LTUH:SP02:TYPE_SUB.VALA")
}
record(mbbi, "CPU:LTUH:SP03:TYPE_RAW") {
 field(DESC, "Device type")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp03+mch")
 field(ZRST, "Unknown")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "MicroTCA")
 field(ONVL, "1")
 field(ONSV, "NO_ALARM")
 field(TWST, "MicroTCA")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Supermicro")
 field(THVL, "3")
 field(THSV, "NO_ALARM")
 field(FRST, "ATCA")
 field(FRVL, "4")
 field(FRSV, "NO_ALARM")
 field(FVVL, "5")
 field(FVST, "ATCA")
 field(FVSV, "NO_ALARM")
 field(SXVL, "6")
 field(SXST, "Advantech")
 field(SXSV, "NO_ALARM")
 field(PINI, "YES")
}

record(stringin, "CPU:LTUH:SP03:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-1441")
  info(autosaveFields,"VAL")
}

# Control debug message verbosity
record(mbbo, "CPU:LTUH:SP03:DBG") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "Off")
 field(ONVL, "1")
 field(ONST, "Low")
 field(TWVL, "2")
 field(TWST, "Med")
 field(THVL, "3")
 field(THST, "High")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp03+dbg")
 field(VAL,  "0")
 field(PINI, "YES")
}

record(bi, "CPU:LTUH:SP03:ONLNSTAT") {
 field(DESC, "MCH online status")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp03+stat")
 field(ZNAM, "Offline")
 field(ZSV, "MAJOR")
 field(ONAM, "Online")
 field(OSV, "NO_ALARM")
 field(PINI, "YES")
 alias("CPU:LTUH:SP03:STAT")
}

record(mbbi, "CPU:LTUH:SP03:INIT") {
 field(DESC, "MCH comm initialized")
 field(DTYP, "MCHsensor")
 field(SCAN, "I/O Intr")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp03+init")
 field(ZRST, "Not initialized")
 field(ZRVL, "0")
 field(ZRSV, "MAJOR")
 field(ONST, "Initializing...")
 field(ONVL, "1")
 field(ONSV, "MINOR")
 field(TWST, "Initialized")
 field(TWVL, "2")
 field(TWSV, "NO_ALARM")
 field(THST, "Initialize failed")
 field(THVL, "3")
 field(THSV, "MAJOR")
 field(PINI, "YES")
}

record(bo, "CPU:LTUH:SP03:INITBYP") {
 field(DESC, "Override init for testing")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp03+init")
 field(ZNAM, "Not initialized")
 field(ZSV, "MAJOR")
 field(ONAM, "Initialized")
 field(OSV, "NO_ALARM")
 field(PINI, "NO")
}

record(bo, "CPU:LTUH:SP03:CONNECT") {
 field(DESC, "Enable comm with MCH")
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp03+sess")
 field(ZNAM, "Disconnect")
 field(ZSV,  "MAJOR")
 field(ONAM, "Connect")
 field(OSV,  "NO_ALARM")
 field(VAL, "1")
 field(RVAL, "1")
 field(PINI, "YES") 
 info(autosaveFields,"VAL RVAL")
}

# Add power on, power off, hard-reset, and msg
# PVs to be consistent with other SLAC systems       
record(bo, "CPU:LTUH:SP03:POWEROFF") {     
  field(DESC, "Power off system")            
  field(FLNK, "CPU:LTUH:SP03:POWEROFF1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:SP03:POWEROFF1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP03:POWEROFF2")
}  
record(longout, "CPU:LTUH:SP03:POWEROFF2") {     
  field(DESC, "Power off system")            
  field(DOL, "0")
  field(OUT, "CPU:LTUH:SP03:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP03:POWEROFF3")
}  
record(calcout, "CPU:LTUH:SP03:POWEROFF3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP03:POWEROFFSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:SP03:POWERMSG PP")
#  field(DOL2, "0")                 
#  field(LNK2, "CPU:LTUH:SP03:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP03:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP03:POWERON") {
  field(DESC, "Power on system")            
  field(FLNK, "CPU:LTUH:SP03:POWERON1")
  field(PINI, "NO")             
}                                 
record(longout, "CPU:LTUH:SP03:POWERON1") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP03:POWERON2")
}  
record(longout, "CPU:LTUH:SP03:POWERON2") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP03:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP03:POWERON3")
}  
record(calcout, "CPU:LTUH:SP03:POWERON3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP03:POWERONSEQ") {
#  field(SELM, "All")              
#  field(DOL1, "2")                 
#  field(LNK1, "CPU:LTUH:SP03:POWERMSG PP")
#  field(DOL2, "1")                
#  field(LNK2, "CPU:LTUH:SP03:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP03:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP03:HARDRESET") {
  field(DESC, "Power cycle system")            
  field(FLNK, "CPU:LTUH:SP03:HARDRESET1")
  field(PINI, "NO")
}                                   
record(longout, "CPU:LTUH:SP03:HARDRESET1") {     
  field(DESC, "Power off system")            
  field(DOL, "3")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP03:HARDRESET2")
}  
record(longout, "CPU:LTUH:SP03:HARDRESET2") {     
  field(DESC, "Power off system")            
  field(DOL, "2")
  field(OUT, "CPU:LTUH:SP03:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP03:HARDRESET3")
}  
record(calcout, "CPU:LTUH:SP03:HARDRESET3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP03:HARDRESETSEQ") {
#  field(SELM, "All")                
#  field(DOL1, "3")                 
#  field(LNK1, "CPU:LTUH:SP03:POWERMSG PP")
#  field(DOL2, "2")                  
#  field(LNK2, "CPU:LTUH:SP03:POWERCTL PP") 
#  field(DLY3, "5")                 
#  field(DOL3, "0")                 
#  field(LNK3, "CPU:LTUH:SP03:POWERMSG PP")
#}                                   

record(bo, "CPU:LTUH:SP03:SOFTSHUTDOWN") {     
  field(DESC, "Soft shutdown system")            
  field(FLNK, "CPU:LTUH:SP03:SOFTSHUTDOWN1")
  field(PINI, "NO")             
}                                               
record(longout, "CPU:LTUH:SP03:SOFTSHUTDOWN1") {     
  field(DESC, "Power off system")            
  field(DOL, "1")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
  field(FLNK, "CPU:LTUH:SP03:SOFTSHUTDOWN2")
}  
record(longout, "CPU:LTUH:SP03:SOFTSHUTDOWN2") {     
  field(DESC, "Power off system")            
  field(DOL, "5")
  field(OUT, "CPU:LTUH:SP03:POWERCTL PP")
  field(FLNK, "CPU:LTUH:SP03:SOFTSHUTDOWN3")
}  
record(calcout, "CPU:LTUH:SP03:SOFTSHUTDOWN3") {     
  field(DESC, "Power off system")            
  field(CALC, "0")
  field(OOPT, "Every Time")
  field(ODLY, "5")
  field(OUT, "CPU:LTUH:SP03:POWERMSG PP")
} 
# Replaced SEQ with linked records above
#record(seq, "CPU:LTUH:SP03:SOFTSHUTDOWNSEQ") {
#  field(SELM, "All")               
#  field(DOL1, "1")                 
#  field(LNK1, "CPU:LTUH:SP03:POWERMSG PP")
#  field(DOL2, "5")                 
#  field(LNK2, "CPU:LTUH:SP03:POWERCTL PP")
#  field(DLY3, "5")                
#  field(DOL3, "0")                
#  field(LNK3, "CPU:LTUH:SP03:POWERMSG PP")
#}                                   

record(mbbo, "CPU:LTUH:SP03:POWERMSG") {
  field(ZRVL, "0")               
  field(ONVL, "1")               
  field(TWVL, "2")               
  field(THVL, "3")               
  field(ONST, "TURNING_OFF")     
  field(TWST, "TURNING_ON")      
  field(THST, "RESETTING")       
  field(ZRSV, "NO_ALARM")        
  field(ONSV, "MINOR")           
  field(TWSV, "MINOR")           
  field(THSV, "MINOR")           
  field(VAL, "0")                
  field(PINI, "YES")             
}                                

# Sends 'Chassis Power' IPMI command
# Vadatech MCH results are unreliable
# NAT MCH does not implement this command
# Dell Server and ATCA crates do seem to implement this
record(mbbo, "CPU:LTUH:SP03:POWERCTL") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp03+chas")
 field(ZRVL, "0")
 field(ZRST, "Power off")
 field(ONVL, "1")
 field(ONST, "Power on")
 field(THVL, "3")
 field(THST, "Hard reset")
# Soft shutdown required by PICMG 3.0
# Tested in ATCA, but not MicroTCA
 field(FVVL, "5")
 field(FVST, "Soft shutdown")
 field(VAL, "1")
}

# Peform IPMI 'Cold Reset'
record(bo, "CPU:LTUH:SP03:RESET") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(OUT, "#B0 C0 N0 @cpu-ltuh-sp03+reset")
}

# Control sensor scan period [seconds]
# Default is 10 seconds
# Added this because PAL systems had 
# trouble at that rate
# Must match SENSOR_SCAN_PERIODS array 
# definition in devMch.c
record(mbbo, "CPU:LTUH:SP03:SENSOR_SCAN_PERIOD") {
 field(DTYP, "MCHsensor")
 field(OMSL, "supervisory")
 field(ZRVL, "0")
 field(ZRST, "5 seconds")
 field(ONVL, "1")
 field(ONST, "10 seconds")
 field(TWVL, "2")
 field(TWST, "20 seconds")
 field(THVL, "3")
 field(THST, "30 seconds")
 field(FRVL, "4")
 field(FRST, "60 seconds")
 field(OUT,  "#B0 C0 N0 @cpu-ltuh-sp03+scan")
 field(VAL,  "1")
 field(RVAL, "1")
 field(PINI, "YES")
 info(autosaveFields,"VAL RVAL")
}
# 24 bits assigned as follows:
# 0-7   power state byte (bit 7 ignored)
# 8-15  last power event byte (bits 5-7 ignored)
# 16-23 misc chassis state byte (bits 4-7 ignored)
record(longin, "CPU:LTUH:SP03:CHASSTAT") {
 field(DESC, "Chassis status")
 field(DTYP, "MCHsensor")
 field(SCAN, "5 second")
 field(INP, "#B0 C0 N0 @cpu-ltuh-sp03+chas")
 field(FLNK, "CPU:LTUH:SP03:POWERINFO_CALC")
}

record(calc, "CPU:LTUH:SP03:POWERINFO_CALC") {
 field(DESC, "Chassis power info")
 field(CALC, "A & 0x7F")
 field(INPA, "CPU:LTUH:SP03:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP03:POWERSTAT_CALC")
}

record(calc, "CPU:LTUH:SP03:POWERSTAT_CALC") {
 field(DESC, "Chassis power status")
 field(CALC, "A & 0x1F")
 field(INPA, "CPU:LTUH:SP03:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:SP03:POWERSTAT")
}

record(longin,"CPU:LTUH:SP03:POWERSTAT") {
  field(DESC, "Chassis power status")
  field(INP,  "CPU:LTUH:SP03:POWERSTAT_CALC MS")
  field(FLNK, "CPU:LTUH:SP03:POWERSTATE_CALC")
}

# Name POWERSTATE to be consistent with other 
# SLAC systems
record(calc,  "CPU:LTUH:SP03:POWERSTATE_CALC") {
  field(DESC, "Power on state")
  field(CALC, "A & 0x1")
  field(INPA, "CPU:LTUH:SP03:POWERSTAT MS")
  field(FLNK, "CPU:LTUH:SP03:POWERSTATE")
}

record(bi,    "CPU:LTUH:SP03:POWERSTATE") {
  field(DESC, "Power on state")
  field(INP,  "CPU:LTUH:SP03:POWERSTATE_CALC MS")
  field(ZNAM, "Not on")
  field(ZSV,  "MAJOR")
  field(ONAM, "On")
  field(OSV,  "NO_ALARM")
  field(FLNK, "CPU:LTUH:SP03:POWERPOLICY_CALC")
}

record(calc, "CPU:LTUH:SP03:POWERPOLICY_CALC") {
 field(DESC, "Chassis power policy")
 field(CALC, "(A & 0x60)>>5")
 field(INPA, "CPU:LTUH:SP03:POWERINFO_CALC MS")
 field(FLNK, "CPU:LTUH:SP03:POWERPOLICY")
}

record(mbbi,  "CPU:LTUH:SP03:POWERPOLICY") {
  field(DESC, "Chassis power policy")
  field(INP,  "CPU:LTUH:SP03:POWERPOLICY_CALC")
  field(ZRST, "Remains off")
  field(ZRVL, "0")
  field(ONST, "Previous state")
  field(ONVL, "1")
  field(TWST, "Powers up")
  field(TWVL, "2")
  field(THST, "Unknown")
  field(THVL, "3")
  field(FLNK, "CPU:LTUH:SP03:MISCSTAT_CALC")
}

record(calc, "CPU:LTUH:SP03:MISCSTAT_CALC") {
 field(DESC, "Chassis misc status")
 field(CALC, "(A & 0x0F0000)>>16")
 field(INPA, "CPU:LTUH:SP03:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP03:MISCSTAT")
}

record(longin, "CPU:LTUH:SP03:MISCSTAT") {
 field(DESC, "Chassis misc status")
 field(INP,  "CPU:LTUH:SP03:MISCSTAT_CALC MS")
 field(FLNK, "CPU:LTUH:SP03:LASTPOWER_CALC")
}

record(calc, "CPU:LTUH:SP03:LASTPOWER_CALC") {
 field(DESC, "Last power event")
 field(CALC, "(A & 0x1F00)>>8")
 field(INPA, "CPU:LTUH:SP03:CHASSTAT MS")
 field(FLNK, "CPU:LTUH:SP03:LASTPOWER")
}

record(mbbi, "CPU:LTUH:SP03:LASTPOWER") {
 field(DESC, "Last power event")
 field(INP,  "CPU:LTUH:SP03:LASTPOWER_CALC MS")
 field(ZRST, "N/A")
 field(ZRVL, "0")
 field(ONST, "AC power failed")
 field(ONVL, "1")
 field(TWST, "Power overload")
 field(TWVL, "2")
 field(THST, "Power interlock")
 field(THVL, "4")
 field(FRST, "Power fault")
 field(FRVL, "8")
 field(FVST, "Remote power on")
 field(FVVL, "32") 
}
# Aliases are temporary for backward-compatibility

# FRU 'presence' record to indicate whether FRU
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FRU0:P") {
  field(DESC, "Module presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C0 N0 @cpu-ltuh-sp03+fpres")
  field(ZNAM, "Not present")
  field(ONAM, "Present")
  field(PINI, "YES")
  alias("CPU:LTUH:SP03:FRU0P")
}

# Vadatech 'hotswap' sensor, provides FRU M-state
record(mbbi, "CPU:LTUH:SP03:FRU0:MSTATE") {
  field(SCAN, "10 second")
#  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C240 N1 @cpu-ltuh-sp03+hs")
  field(ONVL, "0x01")
  field(ONST, "Not Installed")
  field(TWVL, "0x02")
  field(TWST, "Inactive")
  field(THVL, "0x04")
  field(THST, "Activation Request")
  field(FRVL, "0x08")
  field(FRST, "Activation In Progress")
  field(FVVL, "0x10")
  field(FVST, "Active")
  field(SXVL, "0x20")
  field(SXST, "Deactivation Request")
  field(SVVL, "0x40")
  field(SVST, "Deactivation In Progress")
  field(EIVL, "0x80")
  field(EIST, "Communication Lost")
  field(NIVL, "0x100")
  field(NIST, "Not Available")
  alias("CPU:LTUH:SP03:FRU0_MSTATE")
}

record(ai, "CPU:LTUH:SP03:FRU0:FRUID") {
  field(DESC, "Module type")
  field(VAL,  "0")
  field(PINI, "YES")
  alias("CPU:LTUH:SP03:FRU0_FRUID")
}

record(stringin, "CPU:LTUH:SP03:FRU0:BMANUF") {
  field(DESC, "Board manufacturer")
  field(SCAN, "I/O Intr")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+bmf")
  field(PINI, "YES")
  field(FLNK, "CPU:LTUH:SP03:FRU0:BPRODNAME")
  alias("CPU:LTUH:SP03:FRU0_BMANUF")
}

record(stringin, "CPU:LTUH:SP03:FRU0:BPRODNAME") {
  field(DESC, "Board product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+bp")
  field(FLNK, "CPU:LTUH:SP03:FRU0:BSN")
  alias("CPU:LTUH:SP03:FRU0_BPRODNAME")
}

record(stringin, "CPU:LTUH:SP03:FRU0:BSN") {
  field(DESC, "Board serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+bsn")
  field(FLNK, "CPU:LTUH:SP03:FRU0:BPARTNUMBER")
  alias("CPU:LTUH:SP03:FRU0_BSN")
}

record(stringin, "CPU:LTUH:SP03:FRU0:BPARTNUMBER") {
  field(DESC, "Board part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+bpn")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PMANUF")
  alias("CPU:LTUH:SP03:FRU0_BPARTNUMBER")
}

record(stringin, "CPU:LTUH:SP03:FRU0:PMANUF") {
  field(DESC, "Product manufacturer")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+pmf")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PPRODNAME")
  alias("CPU:LTUH:SP03:FRU0_PMANUF")
}

record(stringin, "CPU:LTUH:SP03:FRU0:PPRODNAME") {
  field(DESC, "Product product name")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+pp")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PSN")
  alias("CPU:LTUH:SP03:FRU0_PPRODNAME")
}

record(stringin, "CPU:LTUH:SP03:FRU0:PSN") {
  field(DESC, "Product serial number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+psn")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PPARTNUMBER")
  alias("CPU:LTUH:SP03:FRU0_PSN")
}

record(stringin, "CPU:LTUH:SP03:FRU0:PPARTNUMBER") {
  field(DESC, "Product part number")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+ppn")
  alias("CPU:LTUH:SP03:FRU0_PPARTNUMBER")
}

record(mbbo, "CPU:LTUH:SP03:FRU0:POWERCTL") {
  field(DESC, "Payload power control")
  field(DTYP, "MCHsensor")
  field(OMSL, "supervisory")
  field(OUT, "#B0 C0 N0  @cpu-ltuh-sp03+fru")
  field(ZRST, "Power off")
  field(ONST, "Power on")
#  reset not supported yet
#  field(TWST, "Hard reset")
  alias("CPU:LTUH:SP03:FRU0_POWERCTL")
}

record(ai, "CPU:LTUH:SP03:FRU0:PWR") {
  field(DESC, "Steady state power draw")
  field(SCAN, "10 second")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C0 N0  @cpu-ltuh-sp03+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PWRDES")
  alias("CPU:LTUH:SP03:FRU0_PWR")
}

record(ai, "CPU:LTUH:SP03:FRU0:PWRDES") {
  field(DESC, "Desired steady state power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C1 N0  @cpu-ltuh-sp03+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP03:FRU0:EPWR")
  alias("CPU:LTUH:SP03:FRU0_PWRDES")
}

record(ai, "CPU:LTUH:SP03:FRU0:EPWR") {
  field(DESC, "Early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C2 N0  @cpu-ltuh-sp03+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP03:FRU0:EPWRDES")
  alias("CPU:LTUH:SP03:FRU0_EPWR")
}

record(ai, "CPU:LTUH:SP03:FRU0:EPWRDES") {
  field(DESC, "Desired early power draw")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C3 N0  @cpu-ltuh-sp03+pwr")
  field(EGU, "W")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PWRDLY")
  alias("CPU:LTUH:SP03:FRU0_EPWRDES")
}

record(ai, "CPU:LTUH:SP03:FRU0:PWRDLY") {
  field(DESC, "FRU delay to stable power")
  field(DTYP, "FRUinfo")
  field(INP, "#B0 C4 N0  @cpu-ltuh-sp03+pwr")
  field(EGU, "s")
  field(FLNK, "CPU:LTUH:SP03:FRU0:PWRDYN")
  alias("CPU:LTUH:SP03:FRU0_PWRDLY")
}

record(mbbi, "CPU:LTUH:SP03:FRU0:PWRDYN") {
  field(DESC, "FRU supports dynamic pwr reconfig")
  field(DTYP, "MCHsensor")
  field(INP,  "#B0 C0 N0  @cpu-ltuh-sp03+pwr")
  field(ZRST, "No")
  field(ZRVL, "0")
  field(ONST, "Yes")
  field(ONVL, "1")
  alias("CPU:LTUH:SP03:FRU0_PWRDYN")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N1 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N2 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N3 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N4 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N5 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N6 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N7 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N8 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N9 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N10 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N11 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N12 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N13 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N14 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N15 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N16 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N17 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N18 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N19 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:TEMP20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:TEMP20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:TEMP20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C1 N20 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:TEMP20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N1 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N2 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N3 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N4 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N5 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N6 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N7 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N8 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N9 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N10 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N11 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N12 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N13 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N14 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N15 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N16 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N17 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N18 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N19 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:V20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:V20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:V20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C2 N20 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:V20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N1 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N2 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N3 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N4 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N5 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N6 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N7 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N8 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N9 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N10 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N11 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N12 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I12P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I13") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I13P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I13")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I13P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N13 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I13P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I14") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I14P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I14")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I14P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N14 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I14P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I15") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I15P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I15")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I15P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N15 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I15P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I16") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I16P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I16")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I16P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N16 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I16P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I17") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I17P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I17")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I17P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N17 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I17P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I18") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I18P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I18")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I18P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N18 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I18P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I19") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I19P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I19")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I19P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N19 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I19P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:I20") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:I20P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I20")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:I20P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C3 N20 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:I20P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED1") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED1P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED1")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED1P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N1 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED1P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED2") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED2P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED2")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED2P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N2 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED2P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED3") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED3P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED3")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED3P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N3 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED3P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED4") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED4P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED4")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED4P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N4 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED4P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED5") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED5P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED5")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED5P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N5 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED5P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED6") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED6P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED6")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED6P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N6 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED6P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED7") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED7P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED7")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED7P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N7 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED7P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED8") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED8P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED8")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED8P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N8 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED8P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED9") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED9P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED9")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED9P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N9 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED9P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED10") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED10P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED10")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED10P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N10 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED10P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED11") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED11P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED11")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED11P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N11 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED11P")
}
# ai sensor record
# DESC, EGU set by device support
record(ai, "CPU:LTUH:SP03:FANSPEED12") {
  field(DESC, "")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-sp03+sens")
  field(PREC, "1")
  field(SDIS, "CPU:LTUH:SP03:FANSPEED12P.SEVR")
  field(DISV, "2")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED12")
}

# sensor 'presence' record to indicate whether sensor 
# is active; used by edm visibility rules
record(bi, "CPU:LTUH:SP03:FANSPEED12P") {
  field(DESC, "Sensor presence")
  field(SCAN, "I/O Intr")
  field(DTYP, "MCHsensor")
  field(INP, "#B0 C4 N12 @cpu-ltuh-sp03+spres")
  field(ZNAM, "Not present")
  field(ZSV,  "MAJOR")
  field(ONAM, "Present")
  field(PINI, "YES")
#  alias("CPU:LTUH:SP03:FANSPEED12P")
}
record(aSub, "CPU:LTUH:SP03:TYPE_SUB") {
  field(DESC, "Determine LCLS device type")
  field(SNAM, "subMchTypeFacility")
  field(PINI, "YES")
  field(FTA,  "DOUBLE")
  field(INPA, "CPU:LTUH:SP03:TYPE_RAW MS CP")
# B-H are 'type' values to be used by
# facility-specific software (in particular
# LCLS IOCManager)
# B is type value for Unknown device
  field(FTB,  "DOUBLE")
  field(INPB, "25")
# C is type value for Vadatech MCH
  field(FTC,  "DOUBLE")
  field(INPC, "26")
# D is type value for NAT MCH
  field(FTD,  "DOUBLE")
  field(INPD, "27")
# E is type value for Supermicro server
  field(FTE,  "DOUBLE")
  field(INPE, "28")
# F is type value for Pentair shelf manager
  field(FTF,  "DOUBLE")
  field(INPF, "30")
# G is type value for Artesyn shelf manager
  field(FTG,  "DOUBLE")
  field(INPG, "30")
# H is type value for Advantech server
  field(FTH,  "DOUBLE")
  field(INPH, "28")
# VALA is 'type' value used in LCLS IOCManager
  field(FTVA, "DOUBLE")
  field(FLNK, "CPU:LTUH:SP03:TYPE_DESC")
}

# Copy description to TYPE.DESC
record(stringout, "CPU:LTUH:SP03:TYPE_DESC") {
  field(OMSL, "closed_loop")
  field(DOL,  "CPU:LTUH:SP03:TYPE_RAW")
  field(OUT,  "CPU:LTUH:SP03:TYPE.DESC")
  field(FLNK, "CPU:LTUH:SP03:TYPE")
}

# DESC filled in by TYPE_DESC PV
record(ai, "CPU:LTUH:SP03:TYPE") {
  field(DESC, "")
  field(INP, "CPU:LTUH:SP03:TYPE_SUB.VALA")
}
