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

%%#include "MachineStateBuffer.h"

int     v[42];
assign  v[0] to "BEND:DMP1:400:INTOL";
assign  v[1] to "BEND:DMP1:400:INTOL_BMIN2";
assign  v[2] to "BEND:DMP1:400:INTOL_BMIN";
assign  v[3] to "BEND:DMP1: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:BYKICK_WD";
assign  v[23] to "MPS:MCC0:1:PICBLM_WD";
assign  v[24] to "MPS:MCC0:2:PICBLM_WD";
assign  v[25] to "MPS:MCC0:PIC997:STATE";
assign  v[26] to "MPS:MCC0:PIC998:STATE";
assign  v[27] to "QUAD:LTU1:720:INTOL";
assign  v[28] to "QUAD:LTU1:720:STATE";
assign  v[29] to "QUAD:LTU1:820:INTOL";
assign  v[30] to "QUAD:LTU1:820:STATE";
assign  v[31] to "QUAD:LTU1:840:INTOL";
assign  v[32] to "QUAD:LTU1:840:STATE";
assign  v[33] to "QUAD:LTU1:860:INTOL";
assign  v[34] to "QUAD:LTU1:860:STATE";
assign  v[35] to "QUAD:LTU1:880:INTOL";
assign  v[36] to "QUAD:LTU1:880:STATE";
assign  v[37] to "RTD:BSY0:16:CLINESUM";
assign  v[38] to "RTD:BSY0:89:PASTD2SUM";
assign  v[39] to "RTD:BSYA:1015:PRESL10SUM";
assign  v[40] to "RTD:BSYA:2060:PASTSL10SUM";
assign  v[41] to "RTD:BSYN:64:NARCSUM";
monitor v;

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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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


