Micro TIBURON.AC_MICRO.HUMIDITY_ALARM {
  Warning threshold = TIBURON.AC_MICRO.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.AC_MICRO.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.AC_MICRO.HUMIDITY
  mnemonic = AcMicroHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.AC_MICRO.TANK_COOLANT_LEVEL_ALARM {
  Warning threshold = TIBURON.AC_MICRO.TANK_COOLANT_LEVEL_WARN_THRESHOLD
  Alarm threshold = TIBURON.AC_MICRO.TANK_COOLANT_LEVEL_ALARM_THRESHOLD
  target = TIBURON.AC_MICRO.TANK_COOLANT_LEVEL
  mnemonic = AcMicroOutbdCoolantLevel
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.AC_MICRO.PRESSURE_ALARM {
  Warning threshold = TIBURON.AC_MICRO.PRESSURE_WARN_THRESHOLD
  Alarm threshold = TIBURON.AC_MICRO.PRESSURE_ALARM_THRESHOLD
  target = TIBURON.AC_MICRO.PRESSURE
  mnemonic = AcMicroPressure
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.AC_MICRO.RESET_EVENT {
  mnemonic = AcMicroReset
  priority = 2
  ackAll
}

Micro TIBURON.AC_MICRO.TEMP_ALARM {
  Warning threshold = TIBURON.AC_MICRO.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.AC_MICRO.TEMP_ALARM_THRESHOLD
  target = TIBURON.AC_MICRO.TEMP
  mnemonic = AcMicroTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Boolean TIBURON.CAMERA.PORT.HOUSING_WATER_ALARM {
  mnemonic = CameraPortHousingWater
  priority = 1
  forward
}

Micro TIBURON.CAMERA.PORT.HUMIDITY_ALARM {
  Warning threshold = TIBURON.CAMERA.PORT.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA.PORT.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.CAMERA.PORT.HUMIDITY
  mnemonic = CameraPortHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.CAMERA.PORT.RESET_EVENT {
  mnemonic = CameraPortReset
  priority = 2
  ackAll
}

Micro TIBURON.CAMERA.PORT.TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA.PORT.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA.PORT.TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA.PORT.TEMP
  mnemonic = CameraPortTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Boolean TIBURON.CAMERA.STBD.HOUSING_WATER_ALARM {
  mnemonic = CameraStbdHousingWater
  priority = 1
  forward
}

Micro TIBURON.CAMERA.STBD.HUMIDITY_ALARM {
  Warning threshold = TIBURON.CAMERA.STBD.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA.STBD.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.CAMERA.STBD.HUMIDITY
  mnemonic = CameraStbdHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.CAMERA.STBD.RESET_EVENT {
  mnemonic = CameraStbdReset
  priority = 2
  ackAll
}

Micro TIBURON.CAMERA.STBD.TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA.STBD.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA.STBD.TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA.STBD.TEMP
  mnemonic = CameraStbdTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Gf5vTest TIBURON.CAMERA_IBC.GF_5V.SELFTEST_STATUS {
  mnemonic = CameraIbcGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Gf TIBURON.CAMERA_IBC.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.CAMERA_IBC.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = CameraIbcGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.CAMERA_IBC.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.CAMERA_IBC.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = CameraIbcGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.CAMERA_IBC.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.CAMERA_IBC.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = CameraIbcGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.CAMERA_IBC.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.CAMERA_IBC.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = CameraIbcGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.CAMERA_IBC.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.GF_5V.TEMP
  mnemonic = CameraIbcGf5vTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.GF_5V.VICOR_VOLTAGE
  mnemonic = CameraIbcGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.CAMERA_IBC.HOUSING_WATER_ALARM {
  mnemonic = CameraIbcHousingWater
  priority = 1
  forward
}

Micro TIBURON.CAMERA_IBC.HUMIDITY_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.HUMIDITY
  mnemonic = CameraIbcHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.CAMERA_IBC.JBOX_WATER_ALARM {
  mnemonic = CameraIbcJboxWater
  priority = 1
  forward
}

Micro TIBURON.CAMERA_IBC.LPS0.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.SW0_CURRENT
  mnemonic = CameraIbcLps0Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS0.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.SW1_CURRENT
  mnemonic = CameraIbcLps0Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS0.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.SW2_CURRENT
  mnemonic = CameraIbcLps0Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS0.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.SW3_CURRENT
  mnemonic = CameraIbcLps0Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS0.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.SWITCH_TEMP
  mnemonic = CameraIbcLps0SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS0.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.VICOR_TEMP
  mnemonic = CameraIbcLps0VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS0.VOLTAGE_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS0.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS0.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS0.VOLTAGE
  mnemonic = CameraIbcLps0Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.SW0_CURRENT
  mnemonic = CameraIbcLps1Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.SW1_CURRENT
  mnemonic = CameraIbcLps1Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.SW2_CURRENT
  mnemonic = CameraIbcLps1Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.SW3_CURRENT
  mnemonic = CameraIbcLps1Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.SWITCH_TEMP
  mnemonic = CameraIbcLps1SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.VICOR_TEMP
  mnemonic = CameraIbcLps1VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CAMERA_IBC.LPS1.VOLTAGE_ALARM {
  Warning threshold = TIBURON.CAMERA_IBC.LPS1.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.CAMERA_IBC.LPS1.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.CAMERA_IBC.LPS1.VOLTAGE
  mnemonic = CameraIbcLps1Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Event TIBURON.CAMERA_IBC.RESET_EVENT {
  mnemonic = CameraIbcReset
  priority = 2
  ackAll
}

Gf TIBURON.LIGHTING_IBC.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.LIGHTING_IBC.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = LightingIbcGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.LIGHTING_IBC.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.LIGHTING_IBC.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = LightingIbcGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.LIGHTING_IBC.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.LIGHTING_IBC.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = LightingIbcGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.LIGHTING_IBC.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.LIGHTING_IBC.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = LightingIbcGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.LIGHTING_IBC.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.GF_5V.TEMP
  mnemonic = LightingIbcGf5vTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.LIGHTING_IBC.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.GF_5V.VICOR_VOLTAGE
  mnemonic = LightingIbcGf5vVicorVoltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.LIGHTING_IBC.HPS0.CURRENT_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.HPS0.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.HPS0.CURRENT_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.HPS0.CURRENT
  mnemonic = LightingIbcHps0Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.LIGHTING_IBC.HPS1.CURRENT_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.HPS1.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.HPS1.CURRENT_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.HPS1.CURRENT
  mnemonic = LightingIbcHps1Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.LIGHTING_IBC.HPS2.CURRENT_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.HPS2.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.HPS2.CURRENT_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.HPS2.CURRENT
  mnemonic = LightingIbcHps2Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.LIGHTING_IBC.HUMIDITY_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.HUMIDITY
  mnemonic = LightingIbcHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.LIGHTING_IBC.RESET_EVENT {
  mnemonic = LightingIbcReset
  priority = 2
  ackAll
}

Micro TIBURON.LIGHTING_IBC.VICOR.PSU0.TEMP_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.VICOR.PSU0.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.VICOR.PSU0.TEMP_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.VICOR.PSU0.TEMP
  mnemonic = LightingIbcVicorPsu0Temp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.LIGHTING_IBC.VICOR.PSU1.TEMP_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.VICOR.PSU1.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.VICOR.PSU1.TEMP_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.VICOR.PSU1.TEMP
  mnemonic = LightingIbcVicorPsu1Temp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Gf TIBURON.PAN_TILT.PORT.EXT_GROUND_FAULT_ALARM {
  target = TIBURON.PAN_TILT.PORT.EXT_GROUND_FAULT_CURRENT
  mnemonic = PanTiltPortExtGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

GfTest TIBURON.PAN_TILT.PORT.GROUND_FAULT_TEST_STATUS {
  mnemonic = PanTiltPortGfTest
  priority = 1
  FailOn priority = 1
  FailOff priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.HOUSING_WATER_ALARM {
  mnemonic = PanTiltPortHousingWater
  priority = 1
}

Micro TIBURON.PAN_TILT.PORT.HUMIDITY_ALARM {
  Warning threshold = TIBURON.PAN_TILT.PORT.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.PAN_TILT.PORT.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.PAN_TILT.PORT.HUMIDITY
  mnemonic = PanTiltPortHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.INITIALIZING {
  mnemonic = PanTiltPortInitializing
  priority = 2
}

Boolean TIBURON.PAN_TILT.PORT.LIGHT.PAN.CONTROLLER_FAULT {
  mnemonic = PanTiltPortLightPanController
  priority = 2
}

Event TIBURON.PAN_TILT.PORT.LIGHT.PAN.MOVE_ERROR {
  mnemonic = PanTiltPortLightPanMove
  priority = 3
  ackAll
}

Event TIBURON.PAN_TILT.PORT.LIGHT.PAN.ZERO_POS_ERROR {
  mnemonic = PanTiltPortLightPanZeroPos
  priority = 3
  ackAll
}

Gf TIBURON.PAN_TILT.PORT.LOCAL_GROUND_FAULT_ALARM {
  target = TIBURON.PAN_TILT.PORT.LOCAL_GROUND_FAULT_CURRENT
  mnemonic = PanTiltPortLocalGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Boolean TIBURON.PAN_TILT.PORT.RAM_TEST_STATUS {
  mnemonic = PanTiltRamTestStatus
  priority = 3
}

Event TIBURON.PAN_TILT.PORT.RESET_EVENT {
  mnemonic = PanTiltPortReset
  priority = 2
  ackAll
}

Micro TIBURON.PAN_TILT.PORT.STEPPER_TEMP_ALARM {
  Warning threshold = TIBURON.PAN_TILT.PORT.STEPPER_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PAN_TILT.PORT.STEPPER_TEMP_ALARM_THRESHOLD
  target = TIBURON.PAN_TILT.PORT.STEPPER_TEMP
  mnemonic = PanTiltPortStepperTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PAN_TILT.PORT.TEMP_ALARM {
  Warning threshold = TIBURON.PAN_TILT.PORT.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PAN_TILT.PORT.TEMP_ALARM_THRESHOLD
  target = TIBURON.PAN_TILT.PORT.TEMP
  mnemonic = PanTiltPortTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Boolean TIBURON.PAN_TILT.PORT.LIGHT.PAN.DELTA_POSITION_ALARM {
  mnemonic = PanTiltPortLightPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.LIGHT.TILT.DELTA_POSITION_ALARM {
  mnemonic = PanTiltPortLightTiltDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.CAMERA.PAN.DELTA_POSITION_ALARM {
  mnemonic = PanTiltPortCameraPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.CAMERA.TILT.DELTA_POSITION_ALARM {
  mnemonic = PanTiltPortCameraTiltDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.LIGHT.PAN.CONTROLLER_FAULT {
  mnemonic = PanTiltPortLightPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.LIGHT.TILT.CONTROLLER_FAULT {
  mnemonic = PanTiltPortLightTiltDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.CAMERA.PAN.CONTROLLER_FAULT {
  mnemonic = PanTiltPortCameraPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.PORT.CAMERA.TILT.CONTROLLER_FAULT {
  mnemonic = PanTiltPortCameraTiltDelta
  priority = 1
}

Gf TIBURON.PAN_TILT.STBD.EXT_GROUND_FAULT_ALARM {
  target = TIBURON.PAN_TILT.STBD.EXT_GROUND_FAULT_CURRENT
  mnemonic = PanTiltStbdExtGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

GfTest TIBURON.PAN_TILT.STBD.GROUND_FAULT_TEST_STATUS {
  mnemonic = PanTiltStbdGfTest
  priority = 3
  FailOn priority = 3
  FailOff priority = 3
}

Boolean TIBURON.PAN_TILT.STBD.HOUSING_WATER_ALARM {
  mnemonic = PanTiltStbdHousingWater
  priority = 1
}

Micro TIBURON.PAN_TILT.STBD.HUMIDITY_ALARM {
  Warning threshold = TIBURON.PAN_TILT.STBD.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.PAN_TILT.STBD.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.PAN_TILT.STBD.HUMIDITY
  mnemonic = PanTiltStbdHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.INITIALIZING {
  mnemonic = PanTiltStbdInitializing
  priority = 3
}

Gf TIBURON.PAN_TILT.STBD.LOCAL_GROUND_FAULT_ALARM {
  target = TIBURON.PAN_TILT.STBD.LOCAL_GROUND_FAULT_CURRENT
  mnemonic = PanTiltStbdLocalGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Boolean TIBURON.PAN_TILT.STBD.RAM_TEST_STATUS {
  mnemonic = PanTiltStbdRamTestStatus
  priority = 3
}

Event TIBURON.PAN_TILT.STBD.RESET_EVENT {
  mnemonic = PanTiltStbdReset
  priority = 3
  ackAll
}

Micro TIBURON.PAN_TILT.STBD.STEPPER_TEMP_ALARM {
  Warning threshold = TIBURON.PAN_TILT.STBD.STEPPER_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PAN_TILT.STBD.STEPPER_TEMP_ALARM_THRESHOLD
  target = TIBURON.PAN_TILT.STBD.STEPPER_TEMP
  mnemonic = PanTiltStbdStepperTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PAN_TILT.STBD.TEMP_ALARM {
  Warning threshold = TIBURON.PAN_TILT.STBD.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PAN_TILT.STBD.TEMP_ALARM_THRESHOLD
  target = TIBURON.PAN_TILT.STBD.TEMP
  mnemonic = PanTiltStbdTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Boolean TIBURON.PAN_TILT.STBD.LIGHT.PAN.DELTA_POSITION_ALARM {
  mnemonic = PanTiltStbdLightPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.LIGHT.TILT.DELTA_POSITION_ALARM {
  mnemonic = PanTiltStbdLightTiltDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.CAMERA.PAN.DELTA_POSITION_ALARM {
  mnemonic = PanTiltStbdCameraPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.CAMERA.TILT.DELTA_POSITION_ALARM {
  mnemonic = PanTiltStbdCameraTiltDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.LIGHT.PAN.CONTROLLER_FAULT {
  mnemonic = PanTiltStbdLightPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.LIGHT.TILT.CONTROLLER_FAULT {
  mnemonic = PanTiltStbdLightTiltDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.CAMERA.PAN.CONTROLLER_FAULT {
  mnemonic = PanTiltStbdCameraPanDelta
  priority = 1
}

Boolean TIBURON.PAN_TILT.STBD.CAMERA.TILT.CONTROLLER_FAULT {
  mnemonic = PanTiltStbdCameraTiltDelta
  priority = 1
}

Gf TIBURON.PDU_MICRO.EXT_GROUND_FAULT_ALARM {
  target = TIBURON.PDU_MICRO.EXT_GROUND_FAULT_CURRENT
  mnemonic = PduMicroExtGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

GfTest TIBURON.PDU_MICRO.GROUND_FAULT_TEST_STATUS {
  mnemonic = PduMicroGfTest
  priority = 2
  FailOn priority = 2
  FailOff priority = 2
}

Micro TIBURON.PDU_MICRO.OUT_OF_PHASE_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.OUT_OF_PHASE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.OUT_OF_PHASE_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.OUT_OF_PHASE
  mnemonic = PduMicroPhaseImbalance
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.PHASE1_AMPERAGE_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.PHASE1_AMPERAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.PHASE1_AMPERAGE_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.PHASE1_AMPERAGE
  mnemonic = PduMicroPhase1Amperage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.PHASE2_AMPERAGE_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.PHASE2_AMPERAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.PHASE2_AMPERAGE_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.PHASE2_AMPERAGE
  mnemonic = PduMicroPhase2Amperage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.PHASE3_AMPERAGE_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.PHASE3_AMPERAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.PHASE3_AMPERAGE_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.PHASE3_AMPERAGE
  mnemonic = PduMicroPhase3Amperage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PDU_MICRO.RAM_TEST_STATUS {
  mnemonic = PduMicroRamTestStatus
  priority = 3
}

Event TIBURON.PDU_MICRO.RESET_EVENT {
  mnemonic = PduMicroReset
  priority = 2
  ackAll
}

Micro TIBURON.PDU_MICRO.TEMP_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.TEMP_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.TEMP
  mnemonic = PduMicroTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.TRANSFORMER_TEMP_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.TRANSFORMER_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.TRANSFORMER_TEMP_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.TRANSFORMER_TEMP
  mnemonic = PduMicroTransformerTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.VOLTAGE_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.VOLTAGE
  mnemonic = PduMicroVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.VOLTAGE_MIN_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.VOLTAGE_MIN_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.VOLTAGE_MIN_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.VOLTAGE_MIN
  mnemonic = PduMicroVoltageMin
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.WATTAGE_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.WATTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.WATTAGE_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.WATTAGE
  mnemonic = PduMicroWattage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PDU_MICRO.WATTAGE_MIN_ALARM {
  Warning threshold = TIBURON.PDU_MICRO.WATTAGE_MIN_WARN_THRESHOLD
  Alarm threshold = TIBURON.PDU_MICRO.WATTAGE_MIN_ALARM_THRESHOLD
  target = TIBURON.PDU_MICRO.WATTAGE_MIN
  mnemonic = PduMicroWattageMin
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.ACOUSTIC_MODEM.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.ACOUSTIC_MODEM.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.ACOUSTIC_MODEM.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.ACOUSTIC_MODEM.TEMP
  mnemonic = PowerAcousticModemTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.ALTIMETER.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.ALTIMETER.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.ALTIMETER.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.ALTIMETER.CURRENT
  mnemonic = PowerAltimeterCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.BACKUP_LIGHT.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.BACKUP_LIGHT.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.BACKUP_LIGHT.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.BACKUP_LIGHT.CURRENT
  mnemonic = PowerBackupLightCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.BACKUP_LIGHT.SWITCH_TRIP_ALARM {
  mnemonic = PowerBackupLightSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.BIO_LUME_CAMERA.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.BIO_LUME_CAMERA.CURRENT_WARN_THRESH
  Alarm threshold = TIBURON.POWER.BIO_LUME_CAMERA.CURRENT_ALARM_THRESH
  target = TIBURON.POWER.BIO_LUME_CAMERA.CURRENT
  mnemonic = PowerBioLumeCameraCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.CAMERA_DCON.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.CAMERA_DCON.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.CAMERA_DCON.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.CAMERA_DCON.CURRENT
  mnemonic = PowerCameraDconCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.CONDUCTIVITY_SENSOR.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.CONDUCTIVITY_SENSOR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.CONDUCTIVITY_SENSOR.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.CONDUCTIVITY_SENSOR.CURRENT
  mnemonic = PowerConductivitySensorCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.CONSOLE.IDLE_CPU.ALARM {
  Warning threshold = TIBURON.POWER.CONDUCTIVITY_SENSOR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.CONDUCTIVITY_SENSOR.CURRENT_ALARM_THRESHOLD
  target = UNKNOWN
  mnemonic = ConsoleIdleCpu
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.DOPPLER_SONAR.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.DOPPLER_SONAR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.DOPPLER_SONAR.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.DOPPLER_SONAR.CURRENT
  mnemonic = PowerDopplerSonarCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.DOPPLER_SONAR.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.DOPPLER_SONAR.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.DOPPLER_SONAR.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.DOPPLER_SONAR.TEMP
  mnemonic = PowerDopplerSonarTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.ERS_DCON.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.ERS_DCON.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.ERS_DCON.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.ERS_DCON.CURRENT
  mnemonic = PowerErsDconCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.ERS_PRESSURE.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.ERS_PRESSURE.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.ERS_PRESSURE.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.ERS_PRESSURE.TEMP
  mnemonic = PowerErsPressureTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.GEN_BW_CAMERA1.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.GEN_BW_CAMERA1.CURRENT_WARN_THRESH
  Alarm threshold = TIBURON.POWER.GEN_BW_CAMERA1.CURRENT_ALARM_THRESH
  target = TIBURON.POWER.GEN_BW_CAMERA1.CURRENT
  mnemonic = PowerGenBwCamera1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.GEN_BW_CAMERA2.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.GEN_BW_CAMERA2.CURRENT_WARN_THRESH
  Alarm threshold = TIBURON.POWER.GEN_BW_CAMERA2.CURRENT_ALARM_THRESH
  target = TIBURON.POWER.GEN_BW_CAMERA2.CURRENT
  mnemonic = PowerGenBwCamera2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.GEN_COLOR_CAMERA.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.GEN_COLOR_CAMERA.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.GEN_COLOR_CAMERA.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.GEN_COLOR_CAMERA.CURRENT
  mnemonic = PowerGenColorCameraCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.GYRO.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.GYRO.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.GYRO.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.GYRO.CURRENT
  mnemonic = PowerGyroCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.HYDROPHONE.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.HYDROPHONE.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.HYDROPHONE.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.HYDROPHONE.TEMP
  mnemonic = PowerHydrophoneTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.IMAGING_SONAR.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.IMAGING_SONAR.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.IMAGING_SONAR.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.IMAGING_SONAR.TEMP
  mnemonic = PowerImagingSonarTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.IMAG_SONAR.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.IMAG_SONAR.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.IMAG_SONAR.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.IMAG_SONAR.TEMP
  mnemonic = PowerImagSonarTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.INJECTION_PUMP.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.INJECTION_PUMP.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.INJECTION_PUMP.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.INJECTION_PUMP.CURRENT
  mnemonic = PowerInjectionPumpCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.LIGHTING_DCON_240V.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.LIGHTING_DCON_240V.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.LIGHTING_DCON_240V.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.LIGHTING_DCON_240V.CURRENT
  mnemonic = PowerLightingDcon240vCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.LIGHTING_DCON_240V.SWITCH_TRIP_ALARM {
  mnemonic = PowerLightingDcon240vSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.LIGHTING_DCON_48V.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.LIGHTING_DCON_48V.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.LIGHTING_DCON_48V.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.LIGHTING_DCON_48V.CURRENT
  mnemonic = PowerLightingDcon48vCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.LIGHTS.BALLAST0.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.LIGHTS.BALLAST0.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.LIGHTS.BALLAST0.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.LIGHTS.BALLAST0.CURRENT
  mnemonic = PowerLightsBallast0Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.LIGHTS.BALLAST0.SWITCH_TRIP_ALARM {
  mnemonic = PowerLightsBallast0SwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.LIGHTS.BALLAST1.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.LIGHTS.BALLAST1.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.LIGHTS.BALLAST1.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.LIGHTS.BALLAST1.CURRENT
  mnemonic = PowerLightsBallast1Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.LIGHTS.BALLAST1.SWITCH_TRIP_ALARM {
  mnemonic = PowerLightsBallast1SwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.LIGHTS.BALLAST2.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.LIGHTS.BALLAST2.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.LIGHTS.BALLAST2.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.LIGHTS.BALLAST2.CURRENT
  mnemonic = PowerLightsBallast2Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.LIGHTS.BALLAST2.SWITCH_TRIP_ALARM {
  mnemonic = PowerLightsBallast2SwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.MANIP_240V.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.MANIP_240V.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.MANIP_240V.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.MANIP_240V.CURRENT
  mnemonic = PowerManip240vCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.MANIP_48V.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.MANIP_48V.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.MANIP_48V.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.MANIP_48V.CURRENT
  mnemonic = PowerManip48vCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.OXYGEN_SENSOR.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.OXYGEN_SENSOR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.OXYGEN_SENSOR.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.OXYGEN_SENSOR.CURRENT
  mnemonic = PowerOxygenSensorCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.PAN_TILT.PORT.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.PAN_TILT.PORT.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.PAN_TILT.PORT.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.PAN_TILT.PORT.CURRENT
  mnemonic = PowerPanTiltPortCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Event TIBURON.POWER.PAN_TILT.PORT.TRIP_ALARM {
  mnemonic = PowerPanTiltPortTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.PAN_TILT.STBD.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.PAN_TILT.STBD.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.PAN_TILT.STBD.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.PAN_TILT.STBD.CURRENT
  mnemonic = PowerPanTiltStbdCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Event TIBURON.POWER.PAN_TILT.STBD.TRIP_ALARM {
  mnemonic = PowerPanTiltStbdTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.PILOT_SIT_CAMERA.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.PILOT_SIT_CAMERA.CURRENT_WARN_THRESH
  Alarm threshold = TIBURON.POWER.PILOT_SIT_CAMERA.CURRENT_ALARM_THRESH
  target = TIBURON.POWER.PILOT_SIT_CAMERA.CURRENT
  mnemonic = PowerPilotSitCameraCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.PORT_COLOR_CAMERA.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.PORT_COLOR_CAMERA.CURRENT_WARN_THRESH
  Alarm threshold = TIBURON.POWER.PORT_COLOR_CAMERA.CURRENT_ALARM_THRESH
  target = TIBURON.POWER.PORT_COLOR_CAMERA.CURRENT
  mnemonic = PowerPortColorCameraCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.PRESSURE_SENSOR.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.PRESSURE_SENSOR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.PRESSURE_SENSOR.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.PRESSURE_SENSOR.CURRENT
  mnemonic = PowerPressureSensorCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.RESPONDER.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.RESPONDER.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.RESPONDER.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.RESPONDER.CURRENT
  mnemonic = PowerResponderCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.ROVNAV.TEMP_ALARM {
  Warning threshold = TIBURON.POWER.ROVNAV.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.ROVNAV.TEMP_ALARM_THRESHOLD
  target = TIBURON.POWER.ROVNAV.TEMP
  mnemonic = PowerRovnavTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.SAMPLING_PUMP.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.SAMPLING_PUMP.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.SAMPLING_PUMP.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.SAMPLING_PUMP.CURRENT
  mnemonic = PowerSamplingPumpCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.SENSOR_DCON.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.SENSOR_DCON.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.SENSOR_DCON.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.SENSOR_DCON.CURRENT
  mnemonic = PowerSensorDconCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.SIZING_LASER.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.SIZING_LASER.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.SIZING_LASER.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.SIZING_LASER.CURRENT
  mnemonic = PowerSizingLaserCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.SONAR_DCON.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.SONAR_DCON.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.SONAR_DCON.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.SONAR_DCON.CURRENT
  mnemonic = PowerSonarDconCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.POWER.SPARE_48V.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.SPARE_48V.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.SPARE_48V.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.SPARE_48V.CURRENT
  mnemonic = PowerSpare48vCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.STBD_COLOR_CAMERA.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.STBD_COLOR_CAMERA.CURRENT_WARN_THRES
  Alarm threshold = TIBURON.POWER.STBD_COLOR_CAMERA.CURRENT_ALARM_THRESH
  target = TIBURON.POWER.STBD_COLOR_CAMERA.CURRENT
  mnemonic = PowerStbdColorCameraCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.TEMPERATURE_SENSOR.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.TEMPERATURE_SENSOR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.TEMPERATURE_SENSOR.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.TEMPERATURE_SENSOR.CURRENT
  mnemonic = PowerTemperatureSensorCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.THRUSTER.AFT_LAT.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.THRUSTER.AFT_LAT.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.THRUSTER.AFT_LAT.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.THRUSTER.AFT_LAT.CURRENT
  mnemonic = PowerThrusterAftLatCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.THRUSTER.AFT_LAT.SWITCH_TRIP_ALARM {
  mnemonic = PowerThrusterAftLatSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.THRUSTER.FWD_LAT.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.THRUSTER.FWD_LAT.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.THRUSTER.FWD_LAT.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.THRUSTER.FWD_LAT.CURRENT
  mnemonic = PowerThrusterFwdLatCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.THRUSTER.FWD_LAT.SWITCH_TRIP_ALARM {
  mnemonic = PowerThrusterFwdLatSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.THRUSTER.PORT_HORIZ.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.THRUSTER.PORT_HORIZ.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.THRUSTER.PORT_HORIZ.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.THRUSTER.PORT_HORIZ.CURRENT
  mnemonic = PowerThrusterPortHorizCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.THRUSTER.PORT_HORIZ.SWITCH_TRIP_ALARM {
  mnemonic = PowerThrusterPortHorizSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.THRUSTER.PORT_VERT.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.THRUSTER.PORT_VERT.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.THRUSTER.PORT_VERT.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.THRUSTER.PORT_VERT.CURRENT
  mnemonic = PowerThrusterPortVertCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.THRUSTER.PORT_VERT.SWITCH_TRIP_ALARM {
  mnemonic = PowerThrusterPortVertSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.THRUSTER.STBD_HORIZ.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.THRUSTER.STBD_HORIZ.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.THRUSTER.STBD_HORIZ.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.THRUSTER.STBD_HORIZ.CURRENT
  mnemonic = PowerThrusterStbdHorizCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.THRUSTER.STBD_HORIZ.SWITCH_TRIP_ALARM {
  mnemonic = PowerThrusterStbdHorizSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.THRUSTER.STBD_VERT.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.THRUSTER.STBD_VERT.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.THRUSTER.STBD_VERT.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.THRUSTER.STBD_VERT.CURRENT
  mnemonic = PowerThrusterStbdVertCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.THRUSTER.STBD_VERT.SWITCH_TRIP_ALARM {
  mnemonic = PowerThrusterStbdVertSwitchTrip
  priority = 1
  ackAll
}

Event TIBURON.POWER.TOOLSLED_240V.SWITCH_TRIP_ALARM {
  mnemonic = PowerToolsled240vSwitchTrip
  priority = 1
  ackAll
}

Micro TIBURON.POWER.TOOLSLED_48V.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.TOOLSLED_48V.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.TOOLSLED_48V.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.TOOLSLED_48V.CURRENT
  mnemonic = PowerToolsled48vCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.TRANSMISSOMETER.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.TRANSMISSOMETER.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.TRANSMISSOMETER.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.TRANSMISSOMETER.CURRENT
  mnemonic = PowerTransmissometerCurrent
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.POWER.VB_MOTOR.CURRENT_ALARM {
  Warning threshold = TIBURON.POWER.VB_MOTOR.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.POWER.VB_MOTOR.CURRENT_ALARM_THRESHOLD
  target = TIBURON.POWER.VB_MOTOR.CURRENT
  mnemonic = PowerHydMotorCurrent
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.POWER.VB_MOTOR.SWITCH_TRIP_ALARM {
  mnemonic = PowerHydMotorSwitchTrip
  priority = 1
  ackAll
}

Gf5vTest TIBURON.PWR_IBC_A.GF_5V.SELFTEST_STATUS {
  mnemonic = PwrIbcAGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Gf TIBURON.PWR_IBC_A.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.PWR_IBC_A.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = PwrIbcAGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.PWR_IBC_A.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.PWR_IBC_A.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = PwrIbcAGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.PWR_IBC_A.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.PWR_IBC_A.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = PwrIbcAGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.PWR_IBC_A.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.PWR_IBC_A.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = PwrIbcAGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.PWR_IBC_A.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.GF_5V.TEMP
  mnemonic = PwrIbcAGf5vTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.GF_5V.VICOR_VOLTAGE
  mnemonic = PwrIbcAGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.HPS0.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HPS0.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HPS0.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HPS0.CURRENT
  mnemonic = PwrIbcAHps0Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_A.HPS0.TRIP_ALARM {
  mnemonic = PwrIbcAHps0Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_A.HPS1.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HPS1.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HPS1.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HPS1.CURRENT
  mnemonic = PwrIbcAHps1Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_A.HPS1.TRIP_ALARM {
  mnemonic = PwrIbcAHps1Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_A.HPS2.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HPS2.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HPS2.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HPS2.CURRENT
  mnemonic = PwrIbcAHps2Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_A.HPS2.TRIP_ALARM {
  mnemonic = PwrIbcAHps2Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_A.HPS3.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HPS3.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HPS3.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HPS3.CURRENT
  mnemonic = PwrIbcAHps3Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_A.HPS3.TRIP_ALARM {
  mnemonic = PwrIbcAHps3Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_A.HPS4.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HPS4.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HPS4.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HPS4.CURRENT
  mnemonic = PwrIbcAHps4Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_A.HPS4.TRIP_ALARM {
  mnemonic = PwrIbcAHps4Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_A.HPS5.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HPS5.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HPS5.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HPS5.CURRENT
  mnemonic = PwrIbcAHps5Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_A.HPS5.TRIP_ALARM {
  mnemonic = PwrIbcAHps5Trip
  priority = 1
  ackAll
}

Boolean TIBURON.PWR_IBC_A.IBC_CARD_ERROR {
  mnemonic = PwrIbcACardError
  priority = 3
}

Micro TIBURON.PWR_IBC_A.LPS0.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.SW0_CURRENT
  mnemonic = PwrIbcALps0Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS0.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.SW1_CURRENT
  mnemonic = PwrIbcALps0Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS0.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.SW2_CURRENT
  mnemonic = PwrIbcALps0Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS0.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.SW3_CURRENT
  mnemonic = PwrIbcALps0Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS0.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.SWITCH_TEMP
  mnemonic = PwrIbcALps0SwitchTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.LPS0.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.VICOR_TEMP
  mnemonic = PwrIbcALps0VicorTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.LPS0.VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS0.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS0.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS0.VOLTAGE
  mnemonic = PwrIbcALps0Voltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.LPS1.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.SW0_CURRENT
  mnemonic = PwrIbcALps1Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS1.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.SW1_CURRENT
  mnemonic = PwrIbcALps1Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS1.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.SW2_CURRENT
  mnemonic = PwrIbcALps1Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS1.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.SW3_CURRENT
  mnemonic = PwrIbcALps1Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_A.LPS1.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.SWITCH_TEMP
  mnemonic = PwrIbcALps1SwitchTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.LPS1.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.VICOR_TEMP
  mnemonic = PwrIbcALps1VicorTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.LPS1.VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.LPS1.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.LPS1.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.LPS1.VOLTAGE
  mnemonic = PwrIbcALps1Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Boolean TIBURON.PWR_IBC_A.RAM_TEST_STATUS {
  mnemonic = PwrIbcARamTestStatus
  priority = 3
}

Boolean TIBURON.PWR_IBC_A.REGEN.DUTY_CYCLE_ALARM {
  mnemonic = PwrIbcARegenDutyCycle
  priority = 2
}

Micro TIBURON.PWR_IBC_A.REGEN.HEATER1_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.REGEN.HEATER1_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.REGEN.HEATER1_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.REGEN.HEATER1_TEMP
  mnemonic = PwrIbcARegenHeater1Temp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.REGEN.HEATER2_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.REGEN.HEATER2_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.REGEN.HEATER2_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.REGEN.HEATER2_TEMP
  mnemonic = PwrIbcARegenHeater2Temp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.REGEN.HEATSINK_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.REGEN.HEATSINK_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.REGEN.HEATSINK_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.REGEN.HEATSINK_TEMP
  mnemonic = PwrIbcARegenHeatsinkTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.REGEN.MAX_VOLT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.REGEN.MAX_VOLT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.REGEN.MAX_VOLT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.REGEN.MAX_VOLT
  mnemonic = PwrIbcARegenMaxVolt
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.REGEN.MIN_VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.REGEN.MIN_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.REGEN.MIN_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.REGEN.MIN_VOLTAGE
  mnemonic = PwrIbcARegenMinVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PWR_IBC_A.REGEN.OPEN_HEATER_ALARM {
  mnemonic = PwrIbcARegenOpenHeater
  priority = 1
}

Event TIBURON.PWR_IBC_A.RESET_EVENT {
  mnemonic = PwrIbcAReset
  priority = 2
  ackAll
}

Gf5vTest TIBURON.PWR_IBC_B.GF_5V.SELFTEST_STATUS {
  mnemonic = PwrIbcBGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Gf TIBURON.PWR_IBC_B.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.PWR_IBC_B.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = PwrIbcBGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.PWR_IBC_B.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.PWR_IBC_B.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = PwrIbcBGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.PWR_IBC_B.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.PWR_IBC_B.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = PwrIbcBGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.PWR_IBC_B.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.PWR_IBC_B.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = PwrIbcBGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.PWR_IBC_B.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.GF_5V.TEMP
  mnemonic = PwrIbcBGf5vTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.GF_5V.VICOR_VOLTAGE
  mnemonic = PwrIbcBGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PWR_IBC_B.HOUSING_WATER_ALARM {
  mnemonic = PwrIbcBHousingWater
  priority = 1
  forward
}

Micro TIBURON.PWR_IBC_B.HPS0.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.HPS0.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.HPS0.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.HPS0.CURRENT
  mnemonic = PwrIbcBHps0Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_B.HPS0.TRIP_ALARM {
  mnemonic = PwrIbcBHps0Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_B.HPS1.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.HPS1.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.HPS1.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.HPS1.CURRENT
  mnemonic = PwrIbcBHps1Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_B.HPS1.TRIP_ALARM {
  mnemonic = PwrIbcBHps1Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_B.HPS2.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.HPS2.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.HPS2.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.HPS2.CURRENT
  mnemonic = PwrIbcBHps2Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_B.HPS2.TRIP_ALARM {
  mnemonic = PwrIbcBHps2Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_B.HPS3.CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.HPS3.CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.HPS3.CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.HPS3.CURRENT
  mnemonic = PwrIbcBHps3Current
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.PWR_IBC_B.HPS3.TRIP_ALARM {
  mnemonic = PwrIbcBHps3Trip
  priority = 1
  ackAll
}

Micro TIBURON.PWR_IBC_B.LPS0.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.SW0_CURRENT
  mnemonic = PwrIbcBLps0Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS0.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.SW1_CURRENT
  mnemonic = PwrIbcBLps0Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS0.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.SW2_CURRENT
  mnemonic = PwrIbcBLps0Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS0.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.SW3_CURRENT
  mnemonic = PwrIbcBLps0Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS0.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.SWITCH_TEMP
  mnemonic = PwrIbcBLps0SwitchTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.LPS0.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.VICOR_TEMP
  mnemonic = PwrIbcBLps0VicorTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.LPS0.VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS0.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS0.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS0.VOLTAGE
  mnemonic = PwrIbcBLps0Voltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.LPS1.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.SW0_CURRENT
  mnemonic = PwrIbcBLps1Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS1.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.SW1_CURRENT
  mnemonic = PwrIbcBLps1Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS1.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.SW2_CURRENT
  mnemonic = PwrIbcBLps1Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS1.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.SW3_CURRENT
  mnemonic = PwrIbcBLps1Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.PWR_IBC_B.LPS1.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.SWITCH_TEMP
  mnemonic = PwrIbcBLps1SwitchTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.LPS1.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.VICOR_TEMP
  mnemonic = PwrIbcBLps1VicorTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.LPS1.VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.LPS1.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.LPS1.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.LPS1.VOLTAGE
  mnemonic = PwrIbcBLps1Voltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.REGEN.HEATER1_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.REGEN.HEATER1_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.REGEN.HEATER1_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.REGEN.HEATER1_TEMP
  mnemonic = PwrIbcBRegenHeater1Temp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.REGEN.HEATER2_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.REGEN.HEATER2_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.REGEN.HEATER2_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.REGEN.HEATER2_TEMP
  mnemonic = PwrIbcBRegenHeater2Temp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.REGEN.HEATSINK_TEMP_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.REGEN.HEATSINK_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.REGEN.HEATSINK_TEMP_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.REGEN.HEATSINK_TEMP
  mnemonic = PwrIbcBRegenHeatsinkTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.REGEN.MAX_VOLT_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.REGEN.MAX_VOLT_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.REGEN.MAX_VOLT_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.REGEN.MAX_VOLT
  mnemonic = PwrIbcBRegenMaxVolt
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_B.REGEN.MIN_VOLTAGE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.REGEN.MIN_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.REGEN.MIN_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.REGEN.MIN_VOLTAGE
  mnemonic = PwrIbcBRegenMinVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PWR_IBC_B.REGEN.DUTY_CYCLE_ALARM {
  mnemonic = PwrIbcBRegenDutyCycle
  priority = 1
}

Boolean TIBURON.PWR_IBC_B.REGEN.OPEN_HEATER_ALARM {
  mnemonic = PwrIbcBRegenOpenHeater
  priority = 1
}

Event TIBURON.PWR_IBC_B.RESET_EVENT {
  mnemonic = PwrIbcBReset
  priority = 2
  ackAll
}

Event TIBURON.SENSOR.ALTIMETER.RESET_EVENT {
  mnemonic = SensorAltimeterReset
  priority = 1
  ackAll
}

Micro TIBURON.SENSOR.COMPENSATION.LEVEL_ALARM {
  Warning threshold = TIBURON.SENSOR.COMPENSATION.LEVEL_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR.COMPENSATION.LEVEL_ALARM_THRESHOLD
  target = TIBURON.SENSOR.COMPENSATION.LEVEL
  mnemonic = SensorCompensationLevel
  priority = 1
  Warning priority = 3
  Alarm priority = 1
}

Micro TIBURON.COMPENSATION.LEVEL_ALARM {
  Warning threshold = TIBURON.COMPENSATION.LEVEL_WARN_THRESHOLD
  Alarm threshold = TIBURON.COMPENSATION.LEVEL_ALARM_THRESHOLD
  target = TIBURON.COMPENSATION.LEVEL
  mnemonic = CompensationLevel
  priority = 1
  Warning priority = 3
  Alarm priority = 1
}

Boolean TIBURON.SENSOR.DEPTH.ALARM {
  mnemonic = SensorDepth
  priority = 1
}

Gf5vTest TIBURON.SENSOR_IBC.GF_5V.SELFTEST_STATUS {
  mnemonic = SensorIbcGf5vSelfTest
  priority = 1
  NotRun priority = 1
  AtodFail priority = 1
  TestFail priority = 1
}

Gf TIBURON.SENSOR_IBC.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.SENSOR_IBC.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = SensorIbcGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.SENSOR_IBC.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.SENSOR_IBC.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = SensorIbcGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.SENSOR_IBC.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.SENSOR_IBC.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = SensorIbcGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.SENSOR_IBC.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.SENSOR_IBC.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = SensorIbcGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.SENSOR_IBC.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.GF_5V.TEMP
  mnemonic = SensorIbcGf5vTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.GF_5V.VICOR_VOLTAGE
  mnemonic = SensorIbcGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.SENSOR_IBC.HOUSING_WATER_ALARM {
  mnemonic = SensorIbcHousingWater
  priority = 1
  forward
}

Micro TIBURON.SENSOR_IBC.HUMIDITY_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.HUMIDITY
  mnemonic = SensorIbcHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.SENSOR_IBC.IBC_CARD_ERROR {
  mnemonic = SensorIbcCardError
  priority = 2
}

Boolean TIBURON.SENSOR_IBC.JBOX_WATER_ALARM {
  mnemonic = SensorIbcJboxWater
  priority = 1
  forward
}

Micro TIBURON.SENSOR_IBC.LPS0.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.SW0_CURRENT
  mnemonic = SensorIbcLps0Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS0.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.SW1_CURRENT
  mnemonic = SensorIbcLps0Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS0.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.SW2_CURRENT
  mnemonic = SensorIbcLps0Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS0.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.SW3_CURRENT
  mnemonic = SensorIbcLps0Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS0.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.SWITCH_TEMP
  mnemonic = SensorIbcLps0SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS0.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.VICOR_TEMP
  mnemonic = SensorIbcLps0VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS0.VOLTAGE_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS0.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS0.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS0.VOLTAGE
  mnemonic = SensorIbcLps0Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.SW0_CURRENT
  mnemonic = SensorIbcLps1Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.SW1_CURRENT
  mnemonic = SensorIbcLps1Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.SW2_CURRENT
  mnemonic = SensorIbcLps1Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.SW3_CURRENT
  mnemonic = SensorIbcLps1Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.SWITCH_TEMP
  mnemonic = SensorIbcLps1SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.VICOR_TEMP
  mnemonic = SensorIbcLps1VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SENSOR_IBC.LPS1.VOLTAGE_ALARM {
  Warning threshold = TIBURON.SENSOR_IBC.LPS1.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.SENSOR_IBC.LPS1.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.SENSOR_IBC.LPS1.VOLTAGE
  mnemonic = SensorIbcLps1Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

QuadSerPsuStatus TIBURON.SENSOR_IBC.QUAD_SER0.PSU_STATUS {
  mnemonic = SensorIbcQuadSer0PsuStatus
  priority = 2
}

Boolean TIBURON.SENSOR_IBC.RAM_TEST_STATUS {
  mnemonic = SensorIbcRamTestStatus
  priority = 2
}

Event TIBURON.SENSOR_IBC.RESET_EVENT {
  mnemonic = SensorIbcReset
  priority = 2
  ackAll
}

GfTest TIBURON.SIO32.GROUND_FAULT_TEST_STATUS {
  mnemonic = Sio32GfTest
  priority = 2
  FailOn priority = 2
  FailOff priority = 2
}

Micro TIBURON.SIO32.HUMIDITY_ALARM {
  Warning threshold = TIBURON.SIO32.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.SIO32.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.SIO32.HUMIDITY
  mnemonic = Sio32Humidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Gf TIBURON.SIO32.LOCAL_GROUND_FAULT_ALARM {
  target = TIBURON.SIO32.LOCAL_GROUND_FAULT_CURRENT
  mnemonic = Sio32LocalGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

TelemPsuStatus TIBURON.SIO32.SIO32_PSU_STATUS {
  mnemonic = Sio32PsuStatus
  priority = 1
}

Boolean TIBURON.SIO32.RAM_TEST_STATUS {
  mnemonic = Sio32RamTestStatus
  priority = 1
}

Event TIBURON.SIO32.RESET_EVENT {
  mnemonic = Sio32Reset
  priority = 2
  ackAll
}

Micro TIBURON.SIO32.TEMP_ALARM {
  Warning threshold = TIBURON.SIO32.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SIO32.TEMP_ALARM_THRESHOLD
  target = TIBURON.SIO32.TEMP
  mnemonic = Sio32Temp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Gf5vTest TIBURON.SONAR_IBC.GF_5V.SELFTEST_STATUS {
  mnemonic = SonarIbcGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Gf TIBURON.SONAR_IBC.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.SONAR_IBC.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = SonarIbcGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.SONAR_IBC.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.SONAR_IBC.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = SonarIbcGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.SONAR_IBC.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.SONAR_IBC.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = SonarIbcGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.SONAR_IBC.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.SONAR_IBC.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = SonarIbcGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.SONAR_IBC.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.GF_5V.TEMP
  mnemonic = SonarIbcGf5vTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.GF_5V.VICOR_VOLTAGE
  mnemonic = SonarIbcGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.SONAR_IBC.HOUSING_WATER_ALARM {
  mnemonic = SonarIbcHousingWater
  priority = 1
  forward
}

Micro TIBURON.SONAR_IBC.HUMIDITY_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.HUMIDITY
  mnemonic = SonarIbcHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.SONAR_IBC.IBC_CARD_ERROR {
  mnemonic = SonarIbcCardError
  priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.SW0_CURRENT
  mnemonic = SonarIbcLps0Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.SW1_CURRENT
  mnemonic = SonarIbcLps0Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.SW2_CURRENT
  mnemonic = SonarIbcLps0Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.SW3_CURRENT
  mnemonic = SonarIbcLps0Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.SWITCH_TEMP
  mnemonic = SonarIbcLps0SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.VICOR_TEMP
  mnemonic = SonarIbcLps0VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS0.VOLTAGE_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS0.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS0.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS0.VOLTAGE
  mnemonic = SonarIbcLps0Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.SW0_CURRENT
  mnemonic = SonarIbcLps1Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.SW1_CURRENT
  mnemonic = SonarIbcLps1Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.SW2_CURRENT
  mnemonic = SonarIbcLps1Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.SW3_CURRENT
  mnemonic = SonarIbcLps1Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.SWITCH_TEMP
  mnemonic = SonarIbcLps1SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.VICOR_TEMP
  mnemonic = SonarIbcLps1VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.SONAR_IBC.LPS1.VOLTAGE_ALARM {
  Warning threshold = TIBURON.SONAR_IBC.LPS1.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.SONAR_IBC.LPS1.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.SONAR_IBC.LPS1.VOLTAGE
  mnemonic = SonarIbcLps1Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

QuadSerPsuStatus TIBURON.SONAR_IBC.QUAD_SER0.PSU_STATUS {
  mnemonic = SonarIbcQuadSer0PsuStatus
  priority = 1
}

Boolean TIBURON.SONAR_IBC.RAM_TEST_STATUS {
  mnemonic = SonarIbcRamTestStatus
  priority = 2
}

Event TIBURON.SONAR_IBC.RESET_EVENT {
  mnemonic = SonarIbcReset
  priority = 2
  ackAll
}

Micro TIBURON.TELEMETRY.ROV.BIT_ERROR_RATE_ALARM {
  Warning threshold = TIBURON.TELEMETRY.ROV.BIT_ERROR_RATE_WARN_THRESHOLD
  Alarm threshold = TIBURON.TELEMETRY.ROV.BIT_ERROR_RATE_ALARM_THRESHOLD
  target = TIBURON.TELEMETRY.ROV.BIT_ERROR_RATE
  mnemonic = TelemRovBitErrorRate
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.TELEMETRY.ROV.FDDI_STATUS_ALARM {
  mnemonic = TelemRovFddiStatus
  priority = 1
}

GfTest TIBURON.TELEMETRY.ROV.GROUND_FAULT_TEST_STATUS {
  mnemonic = TelemRovGfTest
  priority = 2
  FailOn priority = 2
  FailOff priority = 2
}

Boolean TIBURON.TELEMETRY.ROV.LASER_STATUS_ALARM {
  mnemonic = TelemRovLaserStatus
  priority = 1
}

Gf TIBURON.TELEMETRY.ROV.LOCAL_GROUND_FAULT_ALARM {
  target = TIBURON.TELEMETRY.ROV.LOCAL_GROUND_FAULT_CURRENT
  mnemonic = TelemRovLocalGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

TelemPsuStatus TIBURON.TELEMETRY.ROV.PSU_STATUS {
  mnemonic = TelemRovPsuStatus
  priority = 1
}

Boolean TIBURON.TELEMETRY.ROV.RAM_TEST_STATUS {
  mnemonic = TelemRovRamTestStatus
  priority = 1
}

Boolean TIBURON.TELEMETRY.ROV.RECV_POWER_ALARM {
  mnemonic = TelemRovRecvPower
  priority = 1
}

Event TIBURON.TELEMETRY.ROV.RESET_EVENT {
  mnemonic = TelemRovReset
  priority = 1
  ackAll
}

Boolean TIBURON.TELEMETRY.ROV.SUB_MUX_BOARD_ALARM {
  mnemonic = TelemRovSubMuxBoard
  priority = 2
}

Micro TIBURON.TELEMETRY.ROV.TEMP_ALARM {
  Warning threshold = TIBURON.TELEMETRY.ROV.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.TELEMETRY.ROV.TEMP_ALARM_THRESHOLD
  target = TIBURON.TELEMETRY.ROV.TEMP
  mnemonic = TelemRovTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.TELEMETRY.TOPSIDE.BIT_ERROR_RATE_ALARM {
  Warning threshold = TIBURON.TELEMETRY.TOPSIDE.BIT_ERROR_RATE_WARN_THRESHOLD
  Alarm threshold = TIBURON.TELEMETRY.TOPSIDE.BIT_ERROR_RATE_ALARM_THRESHOLD
  target = TIBURON.TELEMETRY.TOPSIDE.BIT_ERROR_RATE
  mnemonic = TelemTopsideBitErrorRate
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.TELEMETRY.TOPSIDE.FDDI_STATUS_ALARM {
  mnemonic = TelemTopsideFddiStatus
  priority = 1
}

GfTest TIBURON.TELEMETRY.TOPSIDE.GROUND_FAULT_TEST_STATUS {
  mnemonic = TelemTopsideGfTest
  priority = 2
  FailOn priority = 2
  FailOff priority = 2
}

Boolean TIBURON.TELEMETRY.TOPSIDE.LASER_STATUS_ALARM {
  mnemonic = TelemTopsideLaserStatus
  priority = 1
}

Gf TIBURON.TELEMETRY.TOPSIDE.LOCAL_GROUND_FAULT_ALARM {
  target = TIBURON.TELEMETRY.TOPSIDE.LOCAL_GROUND_FAULT_CURRENT
  mnemonic = TelemTopsideLocalGf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

TelemPsuStatus TIBURON.TELEMETRY.TOPSIDE.PSU_STATUS {
  mnemonic = TelemTopsidePsuStatus
  priority = 4
}

Boolean TIBURON.TELEMETRY.TOPSIDE.RAM_TEST_STATUS {
  mnemonic = TelemTopsideRamTestStatus
  priority = 1
}

Boolean TIBURON.TELEMETRY.TOPSIDE.RECV_POWER_ALARM {
  mnemonic = TelemTopsideRecvPower
  priority = 1
}

Event TIBURON.TELEMETRY.TOPSIDE.RESET_EVENT {
  mnemonic = TelemTopsideReset
  priority = 1
  ackAll
}

Boolean TIBURON.TELEMETRY.TOPSIDE.SUB_MUX_BOARD_ALARM {
  mnemonic = TelemTopsideSubMuxBoard
  priority = 1
}

Micro TIBURON.TELEMETRY.TOPSIDE.TEMP_ALARM {
  Warning threshold = TIBURON.TELEMETRY.TOPSIDE.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.TELEMETRY.TOPSIDE.TEMP_ALARM_THRESHOLD
  target = TIBURON.TELEMETRY.TOPSIDE.TEMP
  mnemonic = TelemTopsideTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Event TIBURON.THRUSTER.AFT_LATERAL.MOTOR_DISABLE_ALARM {
  mnemonic = ThrusterAftLateralMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.AFT_LATERAL.MOTOR_STALL_ALARM {
  mnemonic = ThrusterAftLateralMotorStall
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.AFT_LATERAL.NVRAM_INITIALIZED {
  mnemonic = ThrusterAftLateralNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.THRUSTER.AFT_LATERAL.RAM_TEST_STATUS {
  mnemonic = ThrusterAftLateralRamTestStatus
  priority = 3
}

Event TIBURON.THRUSTER.AFT_LATERAL.RESET_EVENT {
  mnemonic = ThrusterAftLateralReset
  priority = 2
  ackAll
}

Micro TIBURON.THRUSTER.AFT_LATERAL.TEMP_ALARM {
  Warning threshold = TIBURON.THRUSTER.AFT_LATERAL.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.AFT_LATERAL.TEMP_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.AFT_LATERAL.TEMPERATURE
  mnemonic = ThrusterAftLateralTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.THRUSTER.AFT_LATERAL.WATER_ALARM {
  mnemonic = ThrusterAftLateralWater
  priority = 1
  forward
}

Event TIBURON.THRUSTER.FWD_LATERAL.MOTOR_DISABLE_ALARM {
  mnemonic = ThrusterFwdLateralMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.FWD_LATERAL.MOTOR_STALL_ALARM {
  mnemonic = ThrusterFwdLateralMotorStall
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.FWD_LATERAL.NVRAM_INITIALIZED {
  mnemonic = ThrusterFwdLateralNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.THRUSTER.FWD_LATERAL.RAM_TEST_STATUS {
  mnemonic = ThrusterFwdLateralRamTestStatus
  priority = 3
}

Event TIBURON.THRUSTER.FWD_LATERAL.RESET_EVENT {
  mnemonic = ThrusterFwdLateralReset
  priority = 2
  ackAll
}

Micro TIBURON.THRUSTER.FWD_LATERAL.TEMP_ALARM {
  Warning threshold = TIBURON.THRUSTER.FWD_LATERAL.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.FWD_LATERAL.TEMP_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.FWD_LATERAL.TEMPERATURE
  mnemonic = ThrusterFwdLateralTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.THRUSTER.FWD_LATERAL.WATER_ALARM {
  mnemonic = ThrusterFwdLateralWater
  priority = 1
  forward
}

Event TIBURON.THRUSTER.PORT_HORIZ.MOTOR_DISABLE_ALARM {
  mnemonic = ThrusterPortHorizMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.PORT_HORIZ.MOTOR_STALL_ALARM {
  mnemonic = ThrusterPortHorizMotorStall
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.PORT_HORIZ.NVRAM_INITIALIZED {
  mnemonic = ThrusterPortHorizNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.THRUSTER.PORT_HORIZ.RAM_TEST_STATUS {
  mnemonic = ThrusterPortHorizRamTestStatus
  priority = 3
}

Event TIBURON.THRUSTER.PORT_HORIZ.RESET_EVENT {
  mnemonic = ThrusterPortHorizReset
  priority = 2
  ackAll
}

Micro TIBURON.THRUSTER.PORT_HORIZ.TEMP_ALARM {
  Warning threshold = TIBURON.THRUSTER.PORT_HORIZ.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.PORT_HORIZ.TEMP_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.PORT_HORIZ.TEMPERATURE
  mnemonic = ThrusterPortHorizTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.THRUSTER.PORT_HORIZ.WATER_ALARM {
  mnemonic = ThrusterPortHorizWater
  priority = 1
  forward
}

Event TIBURON.THRUSTER.PORT_VERT.MOTOR_DISABLE_ALARM {
  mnemonic = ThrusterPortVertMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.PORT_VERT.MOTOR_STALL_ALARM {
  mnemonic = ThrusterPortVertMotorStall
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.PORT_VERT.NVRAM_INITIALIZED {
  mnemonic = ThrusterPortVertNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.THRUSTER.PORT_VERT.RAM_TEST_STATUS {
  mnemonic = ThrusterPortVertRamTestStatus
  priority = 3
}

Event TIBURON.THRUSTER.PORT_VERT.RESET_EVENT {
  mnemonic = ThrusterPortVertReset
  priority = 2
  ackAll
}

Micro TIBURON.THRUSTER.PORT_VERT.TEMP_ALARM {
  Warning threshold = TIBURON.THRUSTER.PORT_VERT.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.PORT_VERT.TEMP_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.PORT_VERT.TEMPERATURE
  mnemonic = ThrusterPortVertTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.THRUSTER.PORT_VERT.WATER_ALARM {
  mnemonic = ThrusterPortVertWater
  priority = 1
  forward
}

Event TIBURON.THRUSTER.STBD_HORIZ.MOTOR_DISABLE_ALARM {
  mnemonic = ThrusterStbdHorizMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.STBD_HORIZ.MOTOR_STALL_ALARM {
  mnemonic = ThrusterStbdHorizMotorStall
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.STBD_HORIZ.NVRAM_INITIALIZED {
  mnemonic = ThrusterStbdHorizNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.THRUSTER.STBD_HORIZ.RAM_TEST_STATUS {
  mnemonic = ThrusterStbdHorizRamTestStatus
  priority = 3
}

Event TIBURON.THRUSTER.STBD_HORIZ.RESET_EVENT {
  mnemonic = ThrusterStbdHorizReset
  priority = 2
  ackAll
}

Micro TIBURON.THRUSTER.STBD_HORIZ.TEMP_ALARM {
  Warning threshold = TIBURON.THRUSTER.STBD_HORIZ.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.STBD_HORIZ.TEMP_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.STBD_HORIZ.TEMPERATURE
  mnemonic = ThrusterStbdHorizTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.THRUSTER.STBD_HORIZ.WATER_ALARM {
  mnemonic = ThrusterStbdHorizWater
  priority = 1
  forward
}

Event TIBURON.THRUSTER.STBD_VERT.MOTOR_DISABLE_ALARM {
  mnemonic = ThrusterStbdVertMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.STBD_VERT.MOTOR_STALL_ALARM {
  mnemonic = ThrusterStbdVertMotorStall
  priority = 1
  ackAll
}

Event TIBURON.THRUSTER.STBD_VERT.NVRAM_INITIALIZED {
  mnemonic = ThrusterStbdVertNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.THRUSTER.STBD_VERT.RAM_TEST_STATUS {
  mnemonic = ThrusterStbdVertRamTestStatus
  priority = 3
}

Event TIBURON.THRUSTER.STBD_VERT.RESET_EVENT {
  mnemonic = ThrusterStbdVertReset
  priority = 2
  ackAll
}

Micro TIBURON.THRUSTER.STBD_VERT.TEMP_ALARM {
  Warning threshold = TIBURON.THRUSTER.STBD_VERT.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.STBD_VERT.TEMP_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.STBD_VERT.TEMPERATURE
  mnemonic = ThrusterStbdVertTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.THRUSTER.STBD_VERT.WATER_ALARM {
  mnemonic = ThrusterStbdVertWater
  priority = 1
  forward
}

Motor TIBURON.THRUSTER.FWD_LATERAL.STATUS {
  mnemonic = ThrusterFwdLateralStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}

# For Semi-Power thruster controller
Micro TIBURON.THRUSTER.FWD_LATERAL.HUMIDITY_ALARM {
  mnemonic = ThrusterFwdLateralHumidity
  Warning threshold = TIBURON.THRUSTER.FWD_LATERAL.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.FWD_LATERAL.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.FWD_LATERAL.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Motor TIBURON.THRUSTER.AFT_LATERAL.STATUS {
  mnemonic = ThrusterAftLateralStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}

# For Semi-Power thruster controller
Micro TIBURON.THRUSTER.AFT_LATERAL.HUMIDITY_ALARM {
  mnemonic = ThrusterAftLateralHumidity
  Warning threshold = TIBURON.THRUSTER.AFT_LATERAL.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.AFT_LATERAL.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.AFT_LATERAL.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Motor TIBURON.THRUSTER.PORT_HORIZ.STATUS {
  mnemonic = ThrusterPortHorizStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}

# For Semi-Power thruster controller
Micro TIBURON.THRUSTER.PORT_HORIZ.HUMIDITY_ALARM {
  mnemonic = ThrusterPortHorizHumidity
  Warning threshold = TIBURON.THRUSTER.PORT_HORIZ.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.PORT_HORIZ.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.PORT_HORIZ.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}


Motor TIBURON.THRUSTER.STBD_HORIZ.STATUS {
  mnemonic = ThrusterStbdHorizStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}

# For Semi-Power thruster controller
Micro TIBURON.THRUSTER.STBD_HORIZ.HUMIDITY_ALARM {
  mnemonic = ThrusterStbdHorizHumidity
  Warning threshold = TIBURON.THRUSTER.STBD_HORIZ.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.STBD_HORIZ.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.STBD_HORIZ.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Motor TIBURON.THRUSTER.PORT_VERT.STATUS {
  mnemonic = ThrusterPortVertStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}

# For Semi-Power thruster controller
Micro TIBURON.THRUSTER.PORT_VERT.HUMIDITY_ALARM {
  mnemonic = ThrusterPortVertHumidity
  Warning threshold = TIBURON.THRUSTER.PORT_VERT.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.PORT_VERT.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.PORT_VERT.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Motor TIBURON.THRUSTER.STBD_VERT.STATUS {
  mnemonic = ThrusterStbdVertStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}


# For Semi-Power thruster controller
Micro TIBURON.THRUSTER.STBD_VERT.HUMIDITY_ALARM {
  mnemonic = ThrusterStbdVertHumidity
  Warning threshold = TIBURON.THRUSTER.STBD_VERT.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.THRUSTER.STBD_VERT.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.THRUSTER.STBD_VERT.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Motor TIBURON.VB_MOTOR.STATUS {
  mnemonic = HydMotorStatus
  priority = 1
  Unknown priority = 1
  UnderVolt priority = 1
  Temp priority = 1
  Stalled priority = 1
  ResFail priority = 1
  OverCurr priority = 1
  Fault priority = 1
}

Event TIBURON.VB_MOTOR.MOTOR_DISABLE_ALARM {
  mnemonic = HydMotorMotorDisable
  priority = 1
  ackAll
}

Event TIBURON.VB_MOTOR.MOTOR_STALL_ALARM {
  mnemonic = HydMotorMotorStall
  priority = 1
  ackAll
}

Event TIBURON.VB_MOTOR.NVRAM_INITIALIZED {
  mnemonic = HydMotorNVRamInitialized
  priority = 3
  ackAll
}

Boolean TIBURON.VB_MOTOR.RAM_TEST_STATUS {
  mnemonic = HydMotorRamTestStatus
  priority = 3
}

Event TIBURON.VB_MOTOR.RESET_EVENT {
  mnemonic = HydMotorReset
  priority = 2
  ackAll
}

Micro TIBURON.VB_MOTOR.TEMP_ALARM {
  Warning threshold = TIBURON.VB_MOTOR.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.VB_MOTOR.TEMP_ALARM_THRESHOLD
  target = TIBURON.VB_MOTOR.TEMPERATURE
  mnemonic = HydMotorTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.VB_MOTOR.WATER_ALARM {
  mnemonic = HydMotorWater
  priority = 1
  forward
}

# For Semi-Power thruster controller
Micro TIBURON.VB_MOTOR.HUMIDITY_ALARM {
  mnemonic = VbMotorHumidity
  Warning threshold = TIBURON.VB_MOTOR.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.VB_MOTOR.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.VB_MOTOR.HUMIDITY
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.VEHICLE.IDLE_CPU.ALARM {
  target = UNKNOWN
  mnemonic = VehicleIdleCpu
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.VEHICLE.IDLE_CPU2.ALARM {
  target = UNKNOWN
  mnemonic = VehicleIdleCpu2
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Gf5vTest TIBURON.VME_IBC.GF_5V.SELFTEST_STATUS {
  mnemonic = VmeIbcGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Gf TIBURON.VME_IBC.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.VME_IBC.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = VmeIbcGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.VME_IBC.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.VME_IBC.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = VmeIbcGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.VME_IBC.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.VME_IBC.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = VmeIbcGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.VME_IBC.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.VME_IBC.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = VmeIbcGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.VME_IBC.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.VME_IBC.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.GF_5V.TEMP
  mnemonic = VmeIbcGf5vTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.VME_IBC.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.VME_IBC.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.GF_5V.VICOR_VOLTAGE
  mnemonic = VmeIbcGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.VME_IBC.HOUSING_WATER_ALARM {
  mnemonic = VmeIbcHousingWater
  priority = 1
  forward
}

Micro TIBURON.VME_IBC.HUMIDITY_ALARM {
  Warning threshold = TIBURON.VME_IBC.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.HUMIDITY
  mnemonic = VmeIbcHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.VME_IBC.IBC_CARD_ERROR {
  mnemonic = VmeIbcCardError
  priority = 1
}

Micro TIBURON.VME_IBC.LPS0.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.SW0_CURRENT
  mnemonic = VmeIbcLps0Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS0.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.SW1_CURRENT
  mnemonic = VmeIbcLps0Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS0.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.SW2_CURRENT
  mnemonic = VmeIbcLps0Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS0.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.SW3_CURRENT
  mnemonic = VmeIbcLps0Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS0.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.SWITCH_TEMP
  mnemonic = VmeIbcLps0SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS0.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.VICOR_TEMP
  mnemonic = VmeIbcLps0VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS0.VOLTAGE_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS0.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS0.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS0.VOLTAGE
  mnemonic = VmeIbcLps0Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.SW0_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.SW0_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.SW0_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.SW0_CURRENT
  mnemonic = VmeIbcLps1Sw0Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.SW1_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.SW1_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.SW1_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.SW1_CURRENT
  mnemonic = VmeIbcLps1Sw1Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.SW2_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.SW2_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.SW2_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.SW2_CURRENT
  mnemonic = VmeIbcLps1Sw2Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.SW3_CURRENT_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.SW3_CURRENT_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.SW3_CURRENT_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.SW3_CURRENT
  mnemonic = VmeIbcLps1Sw3Current
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.SWITCH_TEMP_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.SWITCH_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.SWITCH_TEMP_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.SWITCH_TEMP
  mnemonic = VmeIbcLps1SwitchTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.VICOR_TEMP_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.VICOR_TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.VICOR_TEMP_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.VICOR_TEMP
  mnemonic = VmeIbcLps1VicorTemp
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

Micro TIBURON.VME_IBC.LPS1.VOLTAGE_ALARM {
  Warning threshold = TIBURON.VME_IBC.LPS1.VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.VME_IBC.LPS1.VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.VME_IBC.LPS1.VOLTAGE
  mnemonic = VmeIbcLps1Voltage
  priority = 2
  Warning priority = 3
  Alarm priority = 2
}

NavPsuStatus TIBURON.VME_IBC.NAV_IF_PSU_STATUS {
  mnemonic = VmeIbcNavIfPsuStatus
  priority = 4
}

QuadSerPsuStatus TIBURON.VME_IBC.QUAD_SER0.PSU_STATUS {
  mnemonic = VmeIbcQuadSer0PsuStatus
  priority = 2
}

Boolean TIBURON.VME_IBC.RAM_TEST_STATUS {
  mnemonic = VmeIbcRamTestStatus
  priority = 1
}

Event TIBURON.VME_IBC.RESET_EVENT {
  mnemonic = VmeIbcReset
  priority = 1
  ackAll
}

VmePsuStatus TIBURON.VME_IBC.VME_PSU_STATUS {
  mnemonic = VmeIbcVmePsuStatus
  priority = 4
}

Boolean TIBURON.VME_IBC.VSP0.ERROR {
  mnemonic = VmeIbcVsp0Error
  priority = 1
}

Boolean TIBURON.VME_IBC.WATER_ALARM0 {
  mnemonic = VmeIbcWaterAlarm0
  priority = 1
  forward
}

Boolean TIBURON.VME_IBC.WATER_ALARM1 {
  mnemonic = VmeIbcWaterAlarm1
  priority = 1
  forward
}

Event TIBURON.EREC_DCON.RESET_EVENT {
  mnemonic = ErecDconReset
  priority = 1
  ackAll
}

Boolean TIBURON.EREC_DCON.RAM_TEST_STATUS {
  mnemonic = ErecDconRamTestStatus
  priority = 1
}

Micro TIBURON.EREC_DCON.BATTERY_VOLTAGE_ALARM {
  Warning threshold = TIBURON.EREC_DCON.BATTERY_VOLTAGE_WARN_THRESH
  Alarm threshold = TIBURON.EREC_DCON.BATTERY_VOLTAGE_ALARM_THRESH
  target = TIBURON.EREC_DCON.BATTERY_VOLTAGE
  mnemonic = ErecDconBatteryVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.EREC_DCON.BATTERY_LIFE_ALARM {
  Warning threshold = TIBURON.EREC_DCON.BATTERY_LIFE_WARN_THRESH
  Alarm threshold = TIBURON.EREC_DCON.BATTERY_LIFE_ALARM_THRESH
  target = TIBURON.EREC_DCON.BATTERY_LIFE
  mnemonic = ErecDconBatteryLife
  priority = 1
  Warning priority = 4
  Alarm priority = 4
}

Micro TIBURON.EREC_DCON.HUMIDITY_ALARM {
  Warning threshold = TIBURON.EREC_DCON.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.EREC_DCON.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.EREC_DCON.HUMIDITY
  mnemonic = ErecDconHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Gf5vTest TIBURON.EREC_DCON.GF_5V.SELFTEST_STATUS {
  mnemonic = ErecDconGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Gf TIBURON.EREC_DCON.GF_5V.CHAN0.GF_ALARM {
  target = TIBURON.EREC_DCON.GF_5V.CHAN0.FAULT_CURRENT
  mnemonic = ErecDconGf5vChan0Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.EREC_DCON.GF_5V.CHAN1.GF_ALARM {
  target = TIBURON.EREC_DCON.GF_5V.CHAN1.FAULT_CURRENT
  mnemonic = ErecDconGf5vChan1Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.EREC_DCON.GF_5V.CHAN2.GF_ALARM {
  target = TIBURON.EREC_DCON.GF_5V.CHAN2.FAULT_CURRENT
  mnemonic = ErecDconGf5vChan2Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Gf TIBURON.EREC_DCON.GF_5V.CHAN3.GF_ALARM {
  target = TIBURON.EREC_DCON.GF_5V.CHAN3.FAULT_CURRENT
  mnemonic = ErecDconGf5vChan3Gf
  priority = 1
  Advisory priority = 3
  Warning priority = 2
  Alarm priority = 1
  forward
}

Micro TIBURON.EREC_DCON.GF_5V.TEMP_ALARM {
  Warning threshold = TIBURON.EREC_DCON.GF_5V.TEMP_WARN_THRESHOLD
  Alarm threshold = TIBURON.EREC_DCON.GF_5V.TEMP_ALARM_THRESHOLD
  target = TIBURON.EREC_DCON.GF_5V.TEMP
  mnemonic = ErecDconGf5vTemp
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.EREC_DCON.GF_5V.VICOR_VOLTAGE_ALARM {
  Warning threshold = TIBURON.EREC_DCON.GF_5V.VICOR_VOLTAGE_WARN_THRESHOLD
  Alarm threshold = TIBURON.EREC_DCON.GF_5V.VICOR_VOLTAGE_ALARM_THRESHOLD
  target = TIBURON.EREC_DCON.GF_5V.VICOR_VOLTAGE
  mnemonic = CameraIbcGf5vVicorVoltage
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.EREC_DCON.JBOX_WATER_ALARM {
  mnemonic = ErecDconJboxWater
  priority = 1
  forward
}

Boolean TIBURON.EREC_DCON.HOUSING_WATER_ALARM {
  mnemonic = ErecDconHousingWater
  priority = 1
  forward
}

Boolean TIBURON.EREC_DCON.IBC_CARD_ERROR {
  mnemonic = ErecDconIbcCardError
  priority = 2
}

Gf5vTest TIBURON.LIGHTING_IBC.GF_5V.SELFTEST_STATUS {
  mnemonic = LightingIbcGf5vSelfTest
  priority = 3
  NotRun priority = 3
  AtodFail priority = 3
  TestFail priority = 3
}

Micro TIBURON.LIGHTING_IBC.HUMIDITY_ALARM {
  Warning threshold = TIBURON.LIGHTING_IBC.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.LIGHTING_IBC.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.LIGHTING_IBC.HUMIDITY
  mnemonic = LightingIbcHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.LIGHTING_IBC.JBOX_WATER_ALARM {
  mnemonic = LightingIbcJboxWater
  priority = 1
  forward
}

Boolean TIBURON.LIGHTING_IBC.HOUSING_WATER_ALARM {
  mnemonic = LightingIbcHousingWater
  priority = 1
  forward
}

Micro TIBURON.PWR_IBC_A.HUMIDITY_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.HUMIDITY
  mnemonic = PwrIbcAHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Micro TIBURON.PWR_IBC_A.TEMPERATURE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_A.TEMPERATURE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_A.TEMPERATURE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_A.TEMPERATURE
  mnemonic = PwrIbcATemperature
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PWR_IBC_A.JBOX_WATER_ALARM {
  mnemonic = PwrIbcAJboxWater
  priority = 1
  forward
}

Boolean TIBURON.PWR_IBC_A.HOUSING_WATER_ALARM {
  mnemonic = PwrIbcAHousingWater
  priority = 1
  forward
}

Micro TIBURON.PWR_IBC_B.HUMIDITY_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.HUMIDITY_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.HUMIDITY_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.HUMIDITY
  mnemonic = PwrIbcBHumidity
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PWR_IBC_B.IBC_CARD_ERROR {
  mnemonic = PwrIbcBIbcCardError
  priority = 2
}

Micro TIBURON.PWR_IBC_B.TEMPERATURE_ALARM {
  Warning threshold = TIBURON.PWR_IBC_B.TEMPERATURE_WARN_THRESHOLD
  Alarm threshold = TIBURON.PWR_IBC_B.TEMPERATURE_ALARM_THRESHOLD
  target = TIBURON.PWR_IBC_B.TEMPERATURE
  mnemonic = PwrIbcBTemperature
  priority = 1
  Warning priority = 2
  Alarm priority = 1
}

Boolean TIBURON.PWR_IBC_B.JBOX_WATER_ALARM {
  mnemonic = PwrIbcBJboxWater
  priority = 1
  forward
}

Boolean TIBURON.PWR_IBC_B.HOUSING_WATER_ALARM {
  mnemonic = PwrIbcBHousingWater
  priority = 1
  forward
}

Boolean TIBURON.PWR_IBC_B.RAM_TEST_STATUS {
  mnemonic = PwrIbcBRamTestStatus
  priority = 3
}

Boolean TIBURON.SONAR_IBC.JBOX_WATER_ALARM {
  mnemonic = SonarIbcJboxWater
  priority = 1
  forward
}

Micro TIBURON.HYDRAULIC_PRESSURE_ALARM {
  Warning threshold = TIBURON.HYDRAULIC_PRESSURE_WARN_THRESHOLD
  Alarm threshold = TIBURON.HYDRAULIC_PRESSURE_ALARM_THRESHOLD
  target = TIBURON.HYDRAULIC_PRESSURE
  mnemonic = HydraulicPressure
  priority = 1
  Warning priority = 4
  Alarm priority = 4
}

Boolean TIBURON.AC_MICRO.AC_CAN_WATER_ALARM {
  mnemonic = AcMicroAcCanWater
  priority = 1
}

Boolean TIBURON.AC_MICRO.TETHER_CAN_WATER_ALARM {
  mnemonic = AcMicroTetherCanWater
  priority = 1
}

Boolean TIBURON.AC_MICRO.RAM_TEST_STATUS {
  mnemonic = AcMicroRamTestStatus
  priority = 3
}

Boolean TIBURON.CAMERA.PORT.RAM_TEST_STATUS {
  mnemonic = CameraPortRamTestStatus
  priority = 1
}

Boolean TIBURON.CAMERA.STBD.RAM_TEST_STATUS {
  mnemonic = CameraStbdRamTestStatus
  priority = 1
}

Boolean TIBURON.CAMERA_IBC.IBC_CARD_ERROR {
  mnemonic = CameraIbcCardError
  priority = 1
}

QuadSerPsuStatus TIBURON.CAMERA_IBC.QUAD_SER0.PSU_STATUS {
  mnemonic = CameraIbcQuadSer0PsuStatus
  priority = 1
}

Boolean TIBURON.CAMERA_IBC.RAM_TEST_STATUS {
  mnemonic = CameraIbcRamTestStatus
  priority = 1
}

Boolean TIBURON.CONTROL.AUTO_ALTITUDE_ERROR {
  mnemonic = ControlAutoAltitudeError
  priority = 1
}

Boolean TIBURON.CONTROL.AUTO_DEPTH_ERROR {
  mnemonic = ControlAutoDepthError
  priority = 1
}

Boolean TIBURON.CONTROL.AUTO_HEADING_ERROR {
  mnemonic = ControlAutoHeadingError
  priority = 1
}

Boolean TIBURON.CONTROL.AUTO_POSITION_ERROR {
  mnemonic = ControlAutoPositionError
  priority = 1
}

Boolean TIBURON.CONTROL.AUTO_Z_ERROR {
  mnemonic = ControlAutoZError
  priority = 1
}

Boolean TIBURON.LIGHTING_IBC.IBC_CARD_ERROR {
  mnemonic = LightingIbcCardError
  priority = 1
}

Boolean TIBURON.LIGHTING_IBC.RAM_TEST_STATUS {
  mnemonic = LightingIbcRamTestStatus
  priority = 1
}

Boolean TIBURON.LIGHTING_IBC.VICOR.PSU0_ERROR_ALARM {
  mnemonic = LightingIbcVicorPsu0Error
  priority = 4
}

Boolean TIBURON.LIGHTING_IBC.VICOR.PSU1_ERROR_ALARM {
  mnemonic = LightingIbcVicorPsu1Error
  priority = 4
}