/*
 * Implementation of mpsEpicsFaultInputs.
 */
 
program mpsEpicsFaultInputs
option -c;

%%#include "MachineStateBuffer.h"

int     v[41];
assign  v[0] to "BEND:DMPH:400:INTOL";
assign  v[1] to "BEND:DMPH:400:INTOL_BMIN2";
assign  v[2] to "BEND:DMPH:400:INTOL_BMIN";
assign  v[3] to "BEND:DMPH:400:STATE";
assign  v[4] to "MPS:MCC0:LION404:STATE";
assign  v[5] to "MPS:MCC0:LION405:STATE";
assign  v[6] to "MPS:MCC0:LION504:STATE";
assign  v[7] to "MPS:MCC0:LION505:STATE";
assign  v[8] to "MPS:MCC0:LION584:STATE";
assign  v[9] to "MPS:MCC0:LION585:STATE";
assign  v[10] to "MPS:MCC0:LION716:STATE";
assign  v[11] to "MPS:MCC0:LION717:STATE";
assign  v[12] to "MPS:MCC0:LION732:STATE";
assign  v[13] to "MPS:MCC0:LION733:STATE";
assign  v[14] to "MPS:MCC0:LION752:STATE";
assign  v[15] to "MPS:MCC0:LION753:STATE";
assign  v[16] to "MPS:MCC0:LION765:STATE";
assign  v[17] to "MPS:MCC0:LION766:STATE";
assign  v[18] to "MPS:BSY0:1:PICBLM_WD";
assign  v[19] to "MPS:IN20:1:PICBLM_WD";
assign  v[20] to "MPS:LI24:1:PICBLM_WD";
assign  v[21] to "MPS:LI30:1:PICBLM_WD";
assign  v[22] to "MPS:MCC0:1:PICBLM_WD";
assign  v[23] to "MPS:MCC0:2:PICBLM_WD";
assign  v[24] to "MPS:MCC0:PIC997:STATE";
assign  v[25] to "MPS:MCC0:PIC998:STATE";
assign  v[26] to "QUAD:LTUH:720:INTOL";
assign  v[27] to "QUAD:LTUH:720:STATE";
assign  v[28] to "QUAD:LTUH:820:INTOL";
assign  v[29] to "QUAD:LTUH:820:STATE";
assign  v[30] to "QUAD:LTUH:840:INTOL";
assign  v[31] to "QUAD:LTUH:840:STATE";
assign  v[32] to "QUAD:LTUH:860:INTOL";
assign  v[33] to "QUAD:LTUH:860:STATE";
assign  v[34] to "QUAD:LTUH:880:INTOL";
assign  v[35] to "QUAD:LTUH:880:STATE";
assign  v[36] to "RTD:BSY0:16:CLINESUM";
assign  v[37] to "RTD:BSY0:89:PASTD2SUM";
assign  v[38] to "RTD:BSYA:1015:PRESL10SUM";
assign  v[39] to "RTD:BSYA:2060:PASTSL10SUM";
assign  v[40] to "RTD:BSYN:64:NARCSUM";
monitor v;

/* State set for PV 0 (BEND:DMPH:400:INTOL), fault number 59 */
ss epicsFaultStateSet0
{
    state low  {
        entry { epicsFaultStateMakeFaulted(59); }
        when(pvConnected(v[0]) && (v[0] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(59); }
        when(!pvConnected(v[0]) || (v[0] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(59) == 0)) { } state low
    }
}



/* State set for PV 1 (BEND:DMPH:400:INTOL_BMIN2), fault number 60 */
ss epicsFaultStateSet1
{
    state low  {
        entry { epicsFaultStateMakeFaulted(60); }
        when(pvConnected(v[1]) && (v[1] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(60); }
        when(!pvConnected(v[1]) || (v[1] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(60) == 0)) { } state low
    }
}



/* State set for PV 2 (BEND:DMPH:400:INTOL_BMIN), fault number 61 */
ss epicsFaultStateSet2
{
    state low  {
        entry { epicsFaultStateMakeFaulted(61); }
        when(pvConnected(v[2]) && (v[2] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(61); }
        when(!pvConnected(v[2]) || (v[2] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(61) == 0)) { } state low
    }
}



/* State set for PV 3 (BEND:DMPH:400:STATE), fault number 62 */
ss epicsFaultStateSet3
{
    state low  {
        entry { epicsFaultStateMakeFaulted(62); }
        when(pvConnected(v[3]) && (v[3] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(62); }
        when(!pvConnected(v[3]) || (v[3] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(62) == 0)) { } state low
    }
}



/* State set for PV 4 (MPS:MCC0:LION404:STATE), fault number 63 */
ss epicsFaultStateSet4
{
    state low  {
        entry { epicsFaultStateMakeFaulted(63); }
        when(pvConnected(v[4]) && (v[4] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(63); }
        when(!pvConnected(v[4]) || (v[4] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(63) == 0)) { } state low
    }
}



/* State set for PV 5 (MPS:MCC0:LION405:STATE), fault number 64 */
ss epicsFaultStateSet5
{
    state low  {
        entry { epicsFaultStateMakeFaulted(64); }
        when(pvConnected(v[5]) && (v[5] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(64); }
        when(!pvConnected(v[5]) || (v[5] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(64) == 0)) { } state low
    }
}



/* State set for PV 6 (MPS:MCC0:LION504:STATE), fault number 65 */
ss epicsFaultStateSet6
{
    state low  {
        entry { epicsFaultStateMakeFaulted(65); }
        when(pvConnected(v[6]) && (v[6] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(65); }
        when(!pvConnected(v[6]) || (v[6] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(65) == 0)) { } state low
    }
}



/* State set for PV 7 (MPS:MCC0:LION505:STATE), fault number 66 */
ss epicsFaultStateSet7
{
    state low  {
        entry { epicsFaultStateMakeFaulted(66); }
        when(pvConnected(v[7]) && (v[7] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(66); }
        when(!pvConnected(v[7]) || (v[7] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(66) == 0)) { } state low
    }
}



/* State set for PV 8 (MPS:MCC0:LION584:STATE), fault number 67 */
ss epicsFaultStateSet8
{
    state low  {
        entry { epicsFaultStateMakeFaulted(67); }
        when(pvConnected(v[8]) && (v[8] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(67); }
        when(!pvConnected(v[8]) || (v[8] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(67) == 0)) { } state low
    }
}



/* State set for PV 9 (MPS:MCC0:LION585:STATE), fault number 68 */
ss epicsFaultStateSet9
{
    state low  {
        entry { epicsFaultStateMakeFaulted(68); }
        when(pvConnected(v[9]) && (v[9] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(68); }
        when(!pvConnected(v[9]) || (v[9] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(68) == 0)) { } state low
    }
}



/* State set for PV 10 (MPS:MCC0:LION716:STATE), fault number 69 */
ss epicsFaultStateSet10
{
    state low  {
        entry { epicsFaultStateMakeFaulted(69); }
        when(pvConnected(v[10]) && (v[10] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(69); }
        when(!pvConnected(v[10]) || (v[10] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(69) == 0)) { } state low
    }
}



/* State set for PV 11 (MPS:MCC0:LION717:STATE), fault number 70 */
ss epicsFaultStateSet11
{
    state low  {
        entry { epicsFaultStateMakeFaulted(70); }
        when(pvConnected(v[11]) && (v[11] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(70); }
        when(!pvConnected(v[11]) || (v[11] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(70) == 0)) { } state low
    }
}



/* State set for PV 12 (MPS:MCC0:LION732:STATE), fault number 71 */
ss epicsFaultStateSet12
{
    state low  {
        entry { epicsFaultStateMakeFaulted(71); }
        when(pvConnected(v[12]) && (v[12] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(71); }
        when(!pvConnected(v[12]) || (v[12] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(71) == 0)) { } state low
    }
}



/* State set for PV 13 (MPS:MCC0:LION733:STATE), fault number 72 */
ss epicsFaultStateSet13
{
    state low  {
        entry { epicsFaultStateMakeFaulted(72); }
        when(pvConnected(v[13]) && (v[13] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(72); }
        when(!pvConnected(v[13]) || (v[13] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(72) == 0)) { } state low
    }
}



/* State set for PV 14 (MPS:MCC0:LION752:STATE), fault number 73 */
ss epicsFaultStateSet14
{
    state low  {
        entry { epicsFaultStateMakeFaulted(73); }
        when(pvConnected(v[14]) && (v[14] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(73); }
        when(!pvConnected(v[14]) || (v[14] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(73) == 0)) { } state low
    }
}



/* State set for PV 15 (MPS:MCC0:LION753:STATE), fault number 74 */
ss epicsFaultStateSet15
{
    state low  {
        entry { epicsFaultStateMakeFaulted(74); }
        when(pvConnected(v[15]) && (v[15] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(74); }
        when(!pvConnected(v[15]) || (v[15] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(74) == 0)) { } state low
    }
}



/* State set for PV 16 (MPS:MCC0:LION765:STATE), fault number 75 */
ss epicsFaultStateSet16
{
    state low  {
        entry { epicsFaultStateMakeFaulted(75); }
        when(pvConnected(v[16]) && (v[16] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(75); }
        when(!pvConnected(v[16]) || (v[16] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(75) == 0)) { } state low
    }
}



/* State set for PV 17 (MPS:MCC0:LION766:STATE), fault number 76 */
ss epicsFaultStateSet17
{
    state low  {
        entry { epicsFaultStateMakeFaulted(76); }
        when(pvConnected(v[17]) && (v[17] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(76); }
        when(!pvConnected(v[17]) || (v[17] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(76) == 0)) { } state low
    }
}



/* State set for PV 18 (MPS:BSY0:1:PICBLM_WD), fault number 77 */
ss epicsFaultStateSet18
{
    state low  {
        entry { epicsFaultStateMakeFaulted(77); }
        when(pvConnected(v[18]) && (v[18] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(77); }
        when(!pvConnected(v[18]) || (v[18] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(77) == 0)) { } state low
    }
}



/* State set for PV 19 (MPS:IN20:1:PICBLM_WD), fault number 78 */
ss epicsFaultStateSet19
{
    state low  {
        entry { epicsFaultStateMakeFaulted(78); }
        when(pvConnected(v[19]) && (v[19] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(78); }
        when(!pvConnected(v[19]) || (v[19] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(78) == 0)) { } state low
    }
}



/* State set for PV 20 (MPS:LI24:1:PICBLM_WD), fault number 79 */
ss epicsFaultStateSet20
{
    state low  {
        entry { epicsFaultStateMakeFaulted(79); }
        when(pvConnected(v[20]) && (v[20] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(79); }
        when(!pvConnected(v[20]) || (v[20] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(79) == 0)) { } state low
    }
}



/* State set for PV 21 (MPS:LI30:1:PICBLM_WD), fault number 80 */
ss epicsFaultStateSet21
{
    state low  {
        entry { epicsFaultStateMakeFaulted(80); }
        when(pvConnected(v[21]) && (v[21] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(80); }
        when(!pvConnected(v[21]) || (v[21] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(80) == 0)) { } state low
    }
}



/* State set for PV 22 (MPS:MCC0:1:PICBLM_WD), fault number 81 */
ss epicsFaultStateSet22
{
    state low  {
        entry { epicsFaultStateMakeFaulted(81); }
        when(pvConnected(v[22]) && (v[22] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(81); }
        when(!pvConnected(v[22]) || (v[22] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(81) == 0)) { } state low
    }
}



/* State set for PV 23 (MPS:MCC0:2:PICBLM_WD), fault number 82 */
ss epicsFaultStateSet23
{
    state low  {
        entry { epicsFaultStateMakeFaulted(82); }
        when(pvConnected(v[23]) && (v[23] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(82); }
        when(!pvConnected(v[23]) || (v[23] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(82) == 0)) { } state low
    }
}



/* State set for PV 24 (MPS:MCC0:PIC997:STATE), fault number 83 */
ss epicsFaultStateSet24
{
    state low  {
        entry { epicsFaultStateMakeFaulted(83); }
        when(pvConnected(v[24]) && (v[24] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(83); }
        when(!pvConnected(v[24]) || (v[24] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(83) == 0)) { } state low
    }
}



/* State set for PV 25 (MPS:MCC0:PIC998:STATE), fault number 84 */
ss epicsFaultStateSet25
{
    state low  {
        entry { epicsFaultStateMakeFaulted(84); }
        when(pvConnected(v[25]) && (v[25] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(84); }
        when(!pvConnected(v[25]) || (v[25] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(84) == 0)) { } state low
    }
}



/* State set for PV 26 (QUAD:LTUH:720:INTOL), fault number 85 */
ss epicsFaultStateSet26
{
    state low  {
        entry { epicsFaultStateMakeFaulted(85); }
        when(pvConnected(v[26]) && (v[26] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(85); }
        when(!pvConnected(v[26]) || (v[26] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(85) == 0)) { } state low
    }
}



/* State set for PV 27 (QUAD:LTUH:720:STATE), fault number 86 */
ss epicsFaultStateSet27
{
    state low  {
        entry { epicsFaultStateMakeFaulted(86); }
        when(pvConnected(v[27]) && (v[27] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(86); }
        when(!pvConnected(v[27]) || (v[27] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(86) == 0)) { } state low
    }
}



/* State set for PV 28 (QUAD:LTUH:820:INTOL), fault number 87 */
ss epicsFaultStateSet28
{
    state low  {
        entry { epicsFaultStateMakeFaulted(87); }
        when(pvConnected(v[28]) && (v[28] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(87); }
        when(!pvConnected(v[28]) || (v[28] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(87) == 0)) { } state low
    }
}



/* State set for PV 29 (QUAD:LTUH:820:STATE), fault number 88 */
ss epicsFaultStateSet29
{
    state low  {
        entry { epicsFaultStateMakeFaulted(88); }
        when(pvConnected(v[29]) && (v[29] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(88); }
        when(!pvConnected(v[29]) || (v[29] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(88) == 0)) { } state low
    }
}



/* State set for PV 30 (QUAD:LTUH:840:INTOL), fault number 89 */
ss epicsFaultStateSet30
{
    state low  {
        entry { epicsFaultStateMakeFaulted(89); }
        when(pvConnected(v[30]) && (v[30] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(89); }
        when(!pvConnected(v[30]) || (v[30] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(89) == 0)) { } state low
    }
}



/* State set for PV 31 (QUAD:LTUH:840:STATE), fault number 90 */
ss epicsFaultStateSet31
{
    state low  {
        entry { epicsFaultStateMakeFaulted(90); }
        when(pvConnected(v[31]) && (v[31] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(90); }
        when(!pvConnected(v[31]) || (v[31] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(90) == 0)) { } state low
    }
}



/* State set for PV 32 (QUAD:LTUH:860:INTOL), fault number 91 */
ss epicsFaultStateSet32
{
    state low  {
        entry { epicsFaultStateMakeFaulted(91); }
        when(pvConnected(v[32]) && (v[32] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(91); }
        when(!pvConnected(v[32]) || (v[32] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(91) == 0)) { } state low
    }
}



/* State set for PV 33 (QUAD:LTUH:860:STATE), fault number 92 */
ss epicsFaultStateSet33
{
    state low  {
        entry { epicsFaultStateMakeFaulted(92); }
        when(pvConnected(v[33]) && (v[33] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(92); }
        when(!pvConnected(v[33]) || (v[33] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(92) == 0)) { } state low
    }
}



/* State set for PV 34 (QUAD:LTUH:880:INTOL), fault number 93 */
ss epicsFaultStateSet34
{
    state low  {
        entry { epicsFaultStateMakeFaulted(93); }
        when(pvConnected(v[34]) && (v[34] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(93); }
        when(!pvConnected(v[34]) || (v[34] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(93) == 0)) { } state low
    }
}



/* State set for PV 35 (QUAD:LTUH:880:STATE), fault number 94 */
ss epicsFaultStateSet35
{
    state low  {
        entry { epicsFaultStateMakeFaulted(94); }
        when(pvConnected(v[35]) && (v[35] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(94); }
        when(!pvConnected(v[35]) || (v[35] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(94) == 0)) { } state low
    }
}



/* State set for PV 36 (RTD:BSY0:16:CLINESUM), fault number 95 */
ss epicsFaultStateSet36
{
    state low  {
        entry { epicsFaultStateMakeFaulted(95); }
        when(pvConnected(v[36]) && (v[36] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(95); }
        when(!pvConnected(v[36]) || (v[36] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(95) == 0)) { } state low
    }
}



/* State set for PV 37 (RTD:BSY0:89:PASTD2SUM), fault number 96 */
ss epicsFaultStateSet37
{
    state low  {
        entry { epicsFaultStateMakeFaulted(96); }
        when(pvConnected(v[37]) && (v[37] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(96); }
        when(!pvConnected(v[37]) || (v[37] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(96) == 0)) { } state low
    }
}



/* State set for PV 38 (RTD:BSYA:1015:PRESL10SUM), fault number 97 */
ss epicsFaultStateSet38
{
    state low  {
        entry { epicsFaultStateMakeFaulted(97); }
        when(pvConnected(v[38]) && (v[38] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(97); }
        when(!pvConnected(v[38]) || (v[38] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(97) == 0)) { } state low
    }
}



/* State set for PV 39 (RTD:BSYA:2060:PASTSL10SUM), fault number 98 */
ss epicsFaultStateSet39
{
    state low  {
        entry { epicsFaultStateMakeFaulted(98); }
        when(pvConnected(v[39]) && (v[39] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(98); }
        when(!pvConnected(v[39]) || (v[39] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(98) == 0)) { } state low
    }
}



/* State set for PV 40 (RTD:BSYN:64:NARCSUM), fault number 99 */
ss epicsFaultStateSet40
{
    state low  {
        entry { epicsFaultStateMakeFaulted(99); }
        when(pvConnected(v[40]) && (v[40] != 0)) { } state high
    }
    
    state high {
        entry { epicsFaultStateMakeOk(99); }
        when(!pvConnected(v[40]) || (v[40] == 0)) { } state low
        when((delay(.1)) && (getLatchedDeviceState(99) == 0)) { } state low
    }
}


