// LoggerService node: See /var/log/messages file.
// +LoggerService = {
// 	Class = LoggerService
// 	CPUs = 0x800
// 	StackSize = 32768
// 	NumberOfLogPages = 128
// 	+SysLogger = {
// 		Class = SysLogger
// 		Format = "EtOoFmC"
// 		PrintKeys = 1
// 		Ident = "JAGyA"
// 	}
// }

// StateMachine node
+StateMachine = {
    Class = StateMachine
    +INITIAL = {
        Class = ReferenceContainer
        +Start = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +DISABLED = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +WAITSTANDBY = {
        Class = ReferenceContainer
        +GoWaitReady = {
            Class = StateMachineEvent
            NextState = "WAITREADY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitReady
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoDisabled = {
            Class = StateMachineEvent
            NextState = "DISABLED"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Disabled
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +WAITREADY = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitPermit = {
            Class = StateMachineEvent
            NextState = "WAITPERMIT"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitPermit
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +WAITPERMIT = {
        Class = ReferenceContainer
        +GoWaitReady = {
            Class = StateMachineEvent
            NextState = "WAITREADY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitReady
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitHVON = {
            Class = StateMachineEvent
            NextState = "WAITHVON"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitHVON
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitHVON_SDN = {
            Class = StateMachineEvent
            NextState = "WAITHVON_SDN"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitHVON_SDN
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitHVON_PREP = {
            Class = StateMachineEvent
            NextState = "WAITHVON_PREP"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitHVON_PREP
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitHVON_SDN_PREP = {
            Class = StateMachineEvent
            NextState = "WAITHVON_SDN_PREP"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitHVON_SDN_PREP
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    // HVPS sequence control states.
    +WAITHVON = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitPermit = {
            Class = StateMachineEvent
            NextState = "WAITPERMIT"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitPermit
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +WAITHVON_SDN = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitPermit = {
            Class = StateMachineEvent
            NextState = "WAITPERMIT"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitPermit
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +WAITHVON_PREP = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitPermit = {
            Class = StateMachineEvent
            NextState = "WAITPERMIT"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitPermit
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +WAITHVON_SDN_PREP = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoWaitPermit = {
            Class = StateMachineEvent
            NextState = "WAITPERMIT"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitPermit
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +GoError = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = Error
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    // Error State (Enter by HVPS errors)
    +ERROR = {
        Class = ReferenceContainer
        +GoWaitStandby = {
            Class = StateMachineEvent
            NextState = "WAITSTANDBY"
            NextStateError = "ERROR"
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareNextStateMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = WaitStandby
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = JAGyrotronRTApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
}

// RealTime Application node
+JAGyrotronRTApp = {
    Class = RealTimeApplication
    +Functions = {
        Class = ReferenceContainer
        //Timer GAM for thread 1.
        +Timer1kHzGAM = {
            Class = IOGAM
            InputSignals = {
                Counter = {
                    DataSource = Timer1kHz
                    Type = uint32
                    Frequency = 1000  //Hz
                }
                Time = {
                    DataSource = Timer1kHz
                    Type = uint32
                }
            }
            OutputSignals = {
                Counter1kHz = {
                    DataSource = DDB1
                    Type = uint32
                }
                Time1kHz = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +Timer10HzGAM = {
            Class = IOGAM
            InputSignals = {
                Counter = {
                    DataSource = Timer10Hz
                    Type = uint32
                    Frequency = 1  //Hz
                }
                Time = {
                    DataSource = Timer10Hz
                    Type = uint32
                }
            }
            OutputSignals = {
                Counter10Hz = {
                    DataSource = DDB1
                    Type = uint32
                }
                Time1Hz = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        //GAM to update PCF state-machine state
        +InErrorGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 1
                }
            }
        }
        +InDisabledGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 2
                }
            }
        }
        +InWaitStandbyGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 3
                }
            }
        }
        +InWaitReadyGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 4
                }
            }
        }
        +InWaitPermitGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 5
                }
            }
        }
        +InWaitHVONGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 6
                }
            }
        }
        +InWaitHVON_PREPGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 7
                }
            }
        }
        +InWaitHVON_SDNGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 8
                }
            }
        }
        +InWaitHVON_SDN_PREPGAM = {
            Class = ConstantGAM
            OutputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 9
                }
            }
        }

        // Copy data from DDB1 to EPICSCAOutput DataSource.
        +EPICSOutputGAM = {
            Class = IOGAM
            InputSignals = {
                PCF_STATE = {
                    DataSource = DDB1
                    Type = uint32
                }
                MCPS_ACT_SP = {
                    DataSource = DDB1
                    Type = uint32
                }
                GCPS_ACT_SP = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                APS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                MCPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                GCPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                FHPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                CSV_LOADED = {
                    DataSource = DDB1
                    Type = uint32
                }
                CSV_ERR = {
                    DataSource = DDB1
                    Type = uint32
                }
                ELAPSED_TIME = {
                    DataSource = DDB1
                    Type = uint32
                }
                HVARMED = {
                    DataSource = DDB1
                    Type = uint32
                }
                HVINJECTION = {
                    DataSource = DDB1
                    Type = uint32
                }
                RFON = {
                    DataSource = DDB1
                    Type = uint32
                }
                MHVPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                PREP_TIME_WF = {
                    DataSource = DDB1
                    Type = int32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                MHVPS_PREP_WF = {
                    DataSource = DDB1
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                BPS_PREP_WF = {
                    DataSource = DDB1
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                APS_PREP_WF = {
                    DataSource = DDB1
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                MCPS_PREP_WF = {
                    DataSource = DDB1
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GCPS_PREP_WF = {
                    DataSource = DDB1
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                FHPS_PREP_WF = {
                    DataSource = DDB1
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                CCPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                MHVPS_STOP = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_STOP = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_STOP = {
                    DataSource = DDB1
                    Type = uint32
                }
                BEAM_ON_TIME = {
                    DataSource = DDB1
                    Type = uint32
                }
                PCF_FLT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BEAM_ON_STAT = {
                    DataSource = DDB1
                    Type = uint32
                }
                SHOT_ID = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                FHPS_AUTO_STAT = {
                    DataSource = DDB1
                    Type = uint32
                }
                //Add 20201117
                APS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                APS_SWON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BPS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BPS_SWON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                MHVPS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                PCF_STATE = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                MCPS_ACT_SP = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                GCPS_ACT_SP = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                BPS_REF = {
                    DataSource = EPICSCAOutput
                    Type = float32
                }
                APS_REF = {
                    DataSource = EPICSCAOutput
                    Type = float32
                }
                MCPS_TRG_CURR_SET = {
                    DataSource = EPICSCAOutput
                    Type = float32
                }
                GCPS_TRG_CURR_SET = {
                    DataSource = EPICSCAOutput
                    Type = float32
                }
                FHPS_REF = {
                    DataSource = EPICSCAOutput
                    Type = float32
                }
                CSV_LOADED = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                CSV_ERR = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                ELAPSED_TIME = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                HVARMED = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                HVINJECTION = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                RFON = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }

                MHVPS_REF = {
                    DataSource = EPICSCAOutput
                    Type = float32
                }
                PREP_TIME_WF = {
                    DataSource = EPICSCAOutput
                }
                MHVPS_PREP_WF = {
                    DataSource = EPICSCAOutput
                }
                BPS_PREP_WF = {
                    DataSource = EPICSCAOutput
                }
                APS_PREP_WF = {
                    DataSource = EPICSCAOutput
                }
                MCPS_PREP_WF = {
                    DataSource = EPICSCAOutput
                }
                GCPS_PREP_WF = {
                    DataSource = EPICSCAOutput
                }
                FHPS_PREP_WF = {
                    DataSource = EPICSCAOutput
                }
                CCPS_REF = {
                    DataSource = EPICSCAOutput
                }
                MHVPS_STOP = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                APS_STOP = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                BPS_STOP = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                BEAM_ON_TIME = {
                    DataSource = EPICSCAOutput
                    Type = uint32
                }
                PCF_FLT = {
                    DataSource = EPICSCAOutput
                }
                BEAM_ON_STAT = {
                    DataSource = EPICSCAOutput
                }
                SHOT_ID = {
                    DataSource = EPICSCAOutput
                }
                FHPS_AUTO_STAT = {
                    DataSource = EPICSCAOutput
                }
                //Added 20201117
                APS_HVON = {
                    DataSource = EPICSCAOutput
                }
                APS_SWON = {
                    DataSource = EPICSCAOutput
                }
                BPS_HVON = {
                    DataSource = EPICSCAOutput
                }
                BPS_SWON = {
                    DataSource = EPICSCAOutput
                }
                MHVPS_HVON = {
                    DataSource = EPICSCAOutput
                }
            }
        }

        // Message GAM in Disabled state.
        +GoWaitStandbyGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {1}
            Comparators = {EQUALS}
            InputSignals = {
                PLC_SELECT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitStandby
            }
        }
        +GoWaitStandbyFromReadyGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {0}
            Comparators = {EQUALS}
            InputSignals = {
                PLC_STANDBY = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitStandby
            }
        }

        // MCPS, GCPS PV to DDB1
        +GCPSGAM = {
            Class = IOGAM
            InputSignals = {
                GCPS_TRG_CURR_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
            }
            OutputSignals = {
                GCPS_TRG_CURR_SET = {
                    DataSource = DDB1
                    Type = float32
                }
            }
        }
        +MCPSGAM = {
            Class = IOGAM
            InputSignals = {
                MCPS_TRG_CURR_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
            }
            OutputSignals = {
                MCPS_TRG_CURR_SET = {
                    DataSource = DDB1
                    Type = float32
                }
            }
        }
        // Message GAM in Standby state.
        +GoDisabledGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {0}
            Comparators = {EQUALS}
            InputSignals = {
                PLC_SELECT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoDisabled
            }
        }

        //GAM in WaitReady state. Check MCPS,GCPS,FHPS state for state transition.
        +GoWaitReadyGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {3 3 1}
            ExpectedFloatValues = {0 0 0}
            Comparators = {EQUALS GREATER EQUALS GREATER EQUALS GREATER}
            InputSignals = {
                MCPS_ACT_RB = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_MCPS_CURR_MON = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                GCPS_ACT_RB = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_GCPS_CURR_MON = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                FHPS_RU = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                FHPS_MEAS_ACV = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitReady
            }
        }

        //GAM for prepro
        +WFRecordGAM = {
            Class = JAWFRecordGAM
            Directory = "../Configurations"  //TODO: Enter directory path for prepro files.
            InputSignals = {
                CSV_LOAD = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                Filename = {
                    Alias = CSV_NAME
                    DataSource = EPICSCAInput
                }
            }
            OutputSignals = {
                PREP_TIME_WF = {
                    DataSource = DDB1
                }
                MHVPS_PREP_WF = {
                    DataSource = DDB1
                }
                BPS_PREP_WF = {
                    DataSource = DDB1
                }
                APS_PREP_WF = {
                    DataSource = DDB1
                }
                MCPS_PREP_WF = {
                    DataSource = DDB1
                }
                GCPS_PREP_WF = {
                    DataSource = DDB1
                }
                FHPS_PREP_WF = {
                    DataSource = DDB1
                }
            }
        }
        +PreProgrammedGAM = {
            Class = JAPreProgrammedGAM
            Directory = "../Configurations" // TODO: Enter the directory path for prepro files.
            PreProgrammedPeriodMs = 1       // Parameter update periods in ms.
            InputSignals = {
                CSV_LOAD = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                Filename = {
                    Alias = CSV_NAME
                    DataSource = EPICSCAInput
                }
                FHPS_REF = {
                    Alias = FHPS_AUTO_TAGV
                    DataSource = EPICSCAInput
                    Type = float32
                }
                RFON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                GYA_PREPRO_TIME = {
                    DataSource = DDB1
                    Type = int32
                }
                MHVPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                BPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                APS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                MCPS_TRG_CURR_SET = {
                    DataSource = DDB1
                    Type = float32
                }
                GCPS_TRG_CURR_SET = {
                    DataSource = DDB1
                    Type = float32
                }
                FHPS_PrePro = {
                    DataSource = DDB1
                    Type = float32
                }
                CSV_LOADED = {
                    DataSource = DDB1
                    Type = uint32
                }
                CSV_ERR = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        //GAM in WaitReady state. Check PLC_READY and CCPS_IN_OPERATION status.
        +GoWaitPermitGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {1 1} //20201222 modified. In the past, 0 1.
            Comparators = {EQUALS EQUALS}
            InputSignals = {
                CCPS_IN_OPERATION = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_READY = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitPermit
            }
        }

        //GAM in WaitPermit state. Check Permit and States of Operation Modes.
        +GoWaitReadyFromWaitPermitGAM = {
            Class = JAMessageGAM
            Operation = OR
            ExpectedIntValues = {0 0}
            Comparators = {EQUALS EQUALS}
            InputSignals = {
                PLC_STANDBY = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_READY = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitReady
            }
        }        
        +GoWaitHVONGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {0 0 1}
            Comparators = {EQUALS EQUALS EQUALS}
            InputSignals = {
                PLC_SYNCMODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PREP_MODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_PERMIT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitHVON
            }
        }
        +GoWaitHVON_PREP_GAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {0 1 1}
            Comparators = {EQUALS EQUALS EQUALS}
            InputSignals = {
                PLC_SYNCMODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PREP_MODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_PERMIT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitHVON_PREP
            }
        }
        +GoWaitHVON_SDN_GAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {1 0 1}
            Comparators = {EQUALS EQUALS EQUALS}
            InputSignals = {
                PLC_SYNCMODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PREP_MODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_PERMIT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitHVON_SDN
            }
        }
        +GoWaitHVON_SDN_PREP_GAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {1 1 1}
            Comparators = {EQUALS EQUALS EQUALS}
            InputSignals = {
                PLC_SYNCMODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PREP_MODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_PERMIT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitHVON_SDN_PREP
            }
        }

        //GAM in WaitHVON_xx states. If PLC_READY is zero, goto WaitStandby.
        +FromWaitHVONToWaitStandby = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {0}
            Comparators = {EQUALS}
            InputSignals = {
                PLC_READY = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitStandby
            }
        }
        //GAM in WaitHVON_xx states. If PLC_PERMIT is zero, goto WaitPermit.
        +FromWaitHVONToWaitPermit = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {0 0 0 0 0 0} //modified 20201222
            Comparators = {EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS} //modified 20201222
            InputSignals = {
                PLC_PERMIT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                //add 20201222
                APS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BPS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                MHVPS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BPS_SWON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                APS_SWON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }//20201222
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitPermit
            }
        }

        // Check the selected mode, and check maximum pulse length. Use with a StateMachineGAM
        +ModeLimitGAM = {
            Class = JAModeControlGAM
            InputSignals = {
                PLC_MODE1 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MD1_SHOTLEN_LIM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_MODE2 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MD2_SHOTLEN_LIM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_MODE3 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MD3_SHOTLEN_LIM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_MODE4 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MD4_SHOTLEN_LIM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                RFON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                Time = {
                    DataSource = DDB1
                    Type = uint32
                }
                HVInjection = {
                	DataSource = RealTimeThreadAsyncBridge
                	Type = uint32
                }
            }
            OutputSignals = {
                MODE_SHOTLEN_FLAG = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        } 

        // State notify GAMs. These GAMs are in all WaitHVON states.
        +writeBeamONStateGAM = {
            Class = IOGAM
            InputSignals = {
                BEAM_ON_STAT = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                BEAM_ON_STAT = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +writeHVArmedStateGAM = {
            Class = IOGAM
            InputSignals = {
                HVARMED = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                HVARMED = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +writeHVInjectionStateGAM = {
            Class = IOGAM
            InputSignals = {
                HVINJECTION = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                HVINJECTION = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +writeRFONStateGAM = {
            Class = IOGAM
            InputSignals = {
                RFON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                RFON = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +writeBeamONTimeGAM = {
            Class = IOGAM
            InputSignals = {
                BeamONTime = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                ELAPSED_TIME = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +writeRFONTimeGAM = {
            Class = IOGAM
            InputSignals = {
                RFONTime = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
            OutputSignals = {
                BEAM_ON_TIME = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        //GAM for trianguler waveform generation.
        +CCPSWaveformGAM = {
            Class = JATriangleWaveGAM
            InputSignals = {
                Frequency = {
                    Alias = CCPS_OUTPUT_FREQ
                    DataSource = EPICSCAInput
                    Type = float32
                }
                Amplitude = {
                    Alias = CCPS_OUTPUT_AMP
                    DataSource = EPICSCAInput
                    Type = float32
                }
                Offset = {
                    Alias = CCPS_OUTPUT_OFFS
                    DataSource = EPICSCAInput
                    Type = float32
                }
                PLCSTANDBY = {
                    Alias = PLC_STANDBY
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            OutputSignals = {
                CCPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
            }
        }
        //GAM for FHPS ramping up operation.
        +FHPSSetpointGAM = {
            Class = IOGAM
            InputSignals = {
                FHPS_AUTO_TAGV = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
            }
            OutputSignals = {
                FHPS_TAGV = {
                    DataSource = DDB1
                    Type = float32
                }
            }
        }
        +FHPSRampupGAM = {
          Class = JARampupGAM
          InputSignals = {
              Currspv = {
                  Alias = FHPS_REF
                  DataSource = DDB1
                  Type = float32
              }
              Targetv = {
                  Alias = FHPS_TAGV
                  DataSource = DDB1
                  Type = float32
              }
              Time = {
                  Alias = FHPS_AUTO_TIME
                  DataSource = EPICSCAInput
                  Type = float32
              }
              Start = {
                  Alias = FHPS_AUTO_START
                  DataSource = EPICSCAInput
                  Type = uint32
              }
              PLC_STANDBY = {
                  Alias = PLC_STANDBY
                  DataSource = EPICSCAInput
                  Type = uint32
              }
              MANUAL_AUTO = {
                  Alias = FHPS_MANM
                  DataSource = EPICSCAInput
                  Type = uint32
              }
              FHPS_PrePro = {
                  DataSource = DDB1
                  Type = float32
              }
          }
          OutputSignals = {
              FHPS_REF = {
                  DataSource = DDB1
                  Type = float32
              }
              FHPS_AUTO_STAT = {
                  DataSource = DDB1
                  Type = uint32
              }
          }
        }
        //GAM for error handling.
        // GAM that sets ERROR and STOP FLAGS for APS, BPS and MHVPS when we enter Error state and resets them when we leave Error state
        +ErrorGAM = {
            Class = JAConditionalSignalUpdateGAM
            Operation = AND
            ExpectedValues = {1 0 0 0 0 0 0 0 0 0 0}
            Comparators = {EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS}
            Values = {0 0 0}
            InputSignals = {
                // Conditional signals
                RESET_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OV = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OC = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MIS_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MISB_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                // Default values
                MHVPS_STOP_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                APS_STOP_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                BPS_STOP_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                MHVPS_STOP = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_STOP = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_STOP = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +StopRequestGAM = {
            Class = JAConditionalSignalUpdateGAM
            Operation = OR
            ExpectedValues = {1 1 1 1 1 1 1 1 1 1}
            Comparators = {EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS}
            Values = {1}
            InputSignals = {
                GYA_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OV = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OC = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MIS_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MISB_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                StopRequest_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                StopRequest = {
                    DataSource = DDB1
                    Type = uint32
                }
            }            
        }

        //Test whether board status are stable
        +GAMDisplayDebug = {
            Class = IOGAM            
            InputSignals = {
                RESET_FLT = {
                    DataSource = DDB1
                    Type = uint32
                }
            } 
            OutputSignals = {
                RESET_FLT_DISP = {
                    DataSource = Display
                    Type = uint32
                }            
            }
        }
        //Check PXI board status.
        +PXI6259ErrorGAM = {
          Class = JAConditionalSignalUpdateGAM
            Operation = OR
            ExpectedValues = {0 0 0 0}
            Comparators = {GREATER GREATER GREATER GREATER}
            Values = {1}
            InputSignals = {
                // Conditional signals
                PXI6259_0 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PXI6259_1 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PXI6528_0 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PXI6528_1 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                // Default values
                PCF_FLT_6259_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                PCF_FLT_6259 = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
         +PXI6368Error03GAM = {// detect Hardware error (status number 3) for PXI6368 boards.
          Class = JAConditionalSignalUpdateGAM
            Operation = OR
            ExpectedValues = {3 3}
            Comparators = {EQUALS EQUALS}
            Values = {1}
            InputSignals = {
                PXI6368_0 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PXI6368_1 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                // Default values
                PCF_FLT_6368_ERRNO_03_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                PCF_FLT_6368_ERRNO_03 = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +PXI6368Error04GAM = {// detect No board error (status number 4) for PXI6368 boards.
          Class = JAConditionalSignalUpdateGAM
            Operation = OR
            ExpectedValues = {4 4}
            Comparators = {EQUALS EQUALS}
            Values = {1}
            InputSignals = {
                PXI6368_0 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PXI6368_1 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                // Default values
                PCF_FLT_6368_ERRNO_04_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                PCF_FLT_6368_ERRNO_04 = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
         +PXIErrorGAM = {
          Class = JAConditionalSignalUpdateGAM
            Operation = OR
            ExpectedValues = {0 0 0}
            Comparators = {GREATER GREATER GREATER}
            Values = {1}
            InputSignals = {
                PCF_FLT_6368_ERRNO_03 = {
                    DataSource = DDB1
                    Type = uint32
                }
                PCF_FLT_6368_ERRNO_04 = {
                    DataSource = DDB1
                    Type = uint32
                }
                PCF_FLT_6259 = {
                    DataSource = DDB1
                    Type = uint32
                }
                // Default values
                PCF_FLT_DEFAULT = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                PCF_FLT = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        

        +FromErrorToWaitStandbyGAM = {
            Class = JAMessageGAM
            Operation = AND
            ExpectedIntValues = {1 0 0 0 0 0 0 0 0 0 0}
            Comparators = {EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS EQUALS}
            InputSignals = {
                RESET_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OV = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OC = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MIS_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MISB_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoWaitStandby
            }
        }
        // From any state to Error state.
        +GoErrorGAM = {
            Class = JAMessageGAM
            Operation = OR
            ExpectedIntValues = {1 1 1 1 1 1 1 1 1 1}
            InputSignals = {
                GYA_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_APS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYA_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                GYB_BPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OV = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_OC = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MIS_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MISB_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_ITL = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            +Event = {
                Class = Message
                Destination = StateMachine
                Function = GoError
            }
        }
        // Reset HVPS outputs. ToDo: Fix to access NI d.s.
        +ResetPSsGAM = {
            Class = ConstantGAM
            OutputSignals = {
                MHVPS_HVON = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                BPS_HVON = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                BPS_SWON = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                APS_HVON = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                APS_SWON = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                //here
            }
        }
        // Update status. ToDo: Fix to access NI d.s.
        +ExitedHVArmedInjectionRFONGAM = {
            Class = JAConditionalSignalUpdateGAM
            Values = {0 0 0}
            InputSignals = {
                // Condition signals
                // Default output values
                HVARMED = {
                    DataSource = DDB1
                    Type = uint32
                }
                HVINJECTION = {
                    DataSource = DDB1
                    Type = uint32
                }
                RFON = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
            OutputSignals = {
                HVARMED = {
                    DataSource = DDB1
                    Type = uint32
                }
                HVINJECTION = {
                    DataSource = DDB1
                    Type = uint32
                }
                RFON = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        //GAM for SDN communication.(ProcessWF:thread1, Subscribe/Publish:thread2)
        +SDNCommandGAM = {
            Class = IOGAM
            InputSignals = {
                Command = {
                    DataSource = SDNSubCommands
                    Type = uint16
                    NumberOfDimensions = 1
                    NumberOfElements = 64
                    Ranges = {{0 0}}
                    // TODO uncomment this for release/testing
                    //Frequency = 1
                }
                ESDNTime = {
                    DataSource = SDNSubCommands
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
            }
            OutputSignals = {
                Command = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint16
                }
                ESDNTime = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +debugSDNGAM = {//for debug
            Class = IOGAM
            InputSignals = {
                Command = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                ESDNTime = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
            OutputSignals = {
                Command_DISP = {
                    DataSource = Display
                    Type = float32
                }
                ESDNTime_DISP = {
                    DataSource = Display
                    Type = uint32
                }
            }
        }
        +SDNReplyGAM = {
            Class = IOGAM
            InputSignals = {
                ESDNTime = {
                    DataSource = DDB1
                    Type = uint32
                }
                WaveformPacketID = {
                    DataSource = DDB1
                    Type = uint16
                }
                GYA_BPS_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_BPS_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_BPS_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_BPS_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_APS_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_APS_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_APS_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_APS_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_ARC1_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_ARC1_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_ARC1_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_ARC1_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_ARC2_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_ARC2_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_ARC2_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_ARC2_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_MHVPS_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_MHVPS_MESVOLT = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_MHVPS_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYB_MHVPS_MESCURR = {
                    DataSource = EPICSCAInput
                    Ranges = {{0 0}}
                }
                GYA_MCPS_CURR_MON = {
                    DataSource = EPICSCAInput
                }
                GYB_MCPS_CURR_MON = {
                    DataSource = EPICSCAInput
                }
                GYA_GCPS_CURR_MON = {
                    DataSource = EPICSCAInput
                }
                GYB_GCPS_CURR_MON = {
                    DataSource = EPICSCAInput
                }
                GYA_FHPS_MEAS_ACI = {
                    DataSource = EPICSCAInput
                }
                GYB_FHPS_MEAS_ACI = {
                    DataSource = EPICSCAInput
                }
                GYA_CCPS_MEAS_DCI = {
                    DataSource = EPICSCAInput
                }
                GYB_CCPS_MEAS_DCI = {
                    DataSource = EPICSCAInput
                }
            }
            OutputSignals = {
                ESDNTime = {
                    DataSource = SDNReply
                    Type = uint32
                    Trigger = 1
                }
                ReplyWaveformAck = {
                    DataSource = SDNReply
                    Type = uint16
                }
                GYA_BPS_MESVOLT = {
                    DataSource = SDNReply
                }
                GYB_BPS_MESVOLT = {
                    DataSource = SDNReply
                }
                GYA_BPS_MESCURR = {
                    DataSource = SDNReply
                }
                GYB_BPS_MESCURR = {
                    DataSource = SDNReply
                }
                GYA_APS_MESVOLT = {
                    DataSource = SDNReply
                }
                GYB_APS_MESVOLT = {
                    DataSource = SDNReply
                }
                GYA_APS_MESCURR = {
                    DataSource = SDNReply
                }
                GYB_APS_MESCURR = {
                    DataSource = SDNReply
                }
                GYA_ARC1_MESVOLT = {
                    DataSource = SDNReply
                }
                GYB_ARC1_MESVOLT = {
                    DataSource = SDNReply
                }
                GYA_ARC1_MESCURR = {
                    DataSource = SDNReply
                }
                GYB_ARC1_MESCURR = {
                    DataSource = SDNReply
                }
                GYA_ARC2_MESVOLT = {
                    DataSource = SDNReply
                }
                GYB_ARC2_MESVOLT = {
                    DataSource = SDNReply
                }
                GYA_ARC2_MESCURR = {
                    DataSource = SDNReply
                }
                GYB_ARC2_MESCURR = {
                    DataSource = SDNReply
                }
                GYA_MHVPS_MESVOLT = {
                    DataSource = SDNReply
                }
                GYB_MHVPS_MESVOLT = {
                    DataSource = SDNReply
                }
                GYA_MHVPS_MESCURR = {
                    DataSource = SDNReply
                }
                GYB_MHVPS_MESCURR = {
                    DataSource = SDNReply
                }
                GYA_MCPS_CURR_MON = {
                    DataSource = SDNReply
                }
                GYB_MCPS_CURR_MON = {
                    DataSource = SDNReply
                }
                GYA_GCPS_CURR_MON = {
                    DataSource = SDNReply
                }
                GYB_GCPS_CURR_MON = {
                    DataSource = SDNReply
                }
                GYA_FHPS_MEAS_ACI = {
                    DataSource = SDNReply
                }
                GYB_FHPS_MEAS_ACI = {
                    DataSource = SDNReply
                }
                GYA_CCPS_MEAS_DCI = {
                    DataSource = SDNReply
                }
                GYB_CCPS_MEAS_DCI = {
                    DataSource = SDNReply
                }
            }
        }
        //Write SDN waveform data into PS setpoint PV.

        // Timer for SDN thread.
        +TimeSDNGAM = {
            Class = IOGAM
            InputSignals = {
                Time = {
                    DataSource = TimerSDN
                    Type = uint32
                }
                Counter = {
                    DataSource = TimerSDN
                    Type = uint32
                    Frequency = 1000 //operation:1k(=1ms cyc), debug:10
                }
            }
            OutputSignals = {
                TimeSDN = {
                    DataSource = DDB1
                    Type = uint32
                }
                CounterSDN = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        //GAM for realtime statemachine
        +Timer100kHzGAM = {
            Class = IOGAM
            InputSignals = {
                Time = {
                    DataSource = Timer
                    Type = uint32
                }
                Counter = {
                    DataSource = Timer
                    Type = uint32
                    Frequency = 200000 //operation:10k(=100us cyc)
                    //Frequency = 100000 //operation:100k(=10us cyc)
                }
                RTThreadPerf = {
                    DataSource = Timings
                    Alias = "WaitHVON.Thread3_CycleTime"
                    Type = uint32
                }
            }
            OutputSignals = {
                Time = {
                    DataSource = DDB1
                    Type = uint32
                }
                Counter = {
                    DataSource = DDB1
                    Type = uint32
                }
                RTThreadPerf = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        // Digital Output port access.
        // EPICS PV to one uint8 variable
        +NI6528P3GAM = {
            Class = JABitSumGAM
            InputSignals = {
                APS_HVON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                APS_SWON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                APS_STOP = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                BPS_HVON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                BPS_SWON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                BPS_STOP = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                BEAM_ON_STAT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                DO_REV5 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }                
            }
            OutputSignals = {
                NI6528P3CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
        }
        +NI6528P4GAM = {
            Class = JABitSumGAM
            InputSignals = {
                DO_REV6 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                DO_REV7 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                DO_REV8 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_HVON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_STOP = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                MHVPS_MODSW = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PCF_FLT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                HVARMED = {
                    DataSource = EPICSCAInput
                    Type = uint32
                } 
            }
            OutputSignals = {
                NI6528P4CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
        }
        +NI6528P5GAM = {
            Class = JABitSumGAM
            InputSignals = {
                HVINJECTION = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                RFON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                FHPS_RU = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                SCM_RU = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                SCM_RD = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                CCPS_IN_OPERATION = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                NONE1 = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
                NONE2 = {
                    DataSource = DDB1
                    Type = uint32
                    Default = 0
                }
            }
            OutputSignals = {
                NI6528P5CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
        }
        // reversed uint8 variable (value to write on port.)
        +NI6528P3PV2PortGAM = {
            Class = JABitReverseGAM
            InputSignals = {
                NI6528P3CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
            OutputSignals = {
                NI6528P3PortValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
        }
        +NI6528P4PV2PortGAM = {
            Class = JABitReverseGAM
            InputSignals = {
                NI6528P4CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
            OutputSignals = {
                NI6528P4PortValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
        }
        +NI6528P5PV2PortGAM = {
            Class = JABitReverseGAM
            InputSignals = {
                NI6528P5CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
            OutputSignals = {
                NI6528P5PortValue = {
                    DataSource = NI6528P5
                    Type = uint8
                }
            }
        }
        // write a uint8 port value to PXI data source.
        +NI6528P3WriteGAM = {
            Class = IOGAM
            InputSignals = {
                NI6528P3PortValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
            OutputSignals = {
                NI6528P3Value = {
                    DataSource = NI6528P3
                    Type = uint8
                }
            }
        }
        +NI6528P4WriteGAM = {
            Class = IOGAM
            InputSignals = {
                NI6528P4PortValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
            OutputSignals = {
                NI6528P4Value = {
                    DataSource = NI6528P4
                    Type = uint8
                }
            }
        }

        //Thread3 pulse parameter EPICS PVs read.
        +GAMEPICSCA = {
            Class = IOGAM
            InputSignals = {
                MHVPS_DT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                APS_HVON_DT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                APS_SWON_DT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                BPS_HVON_DT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                BPS_SWON_DT = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                SHOTLEN = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                PLC_ON = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
            }
            OutputSignals = {
                MHVPS_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_HVON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_SWON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_HVON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_SWON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                SHOTLEN = {
                    DataSource = DDB1
                    Type = uint32
                }
                PLC_ON = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }

        // Real-Time state machine GAMs
        +GAMRealTimeStateMachine = {
            Class = JARTStateMachineGAM
            ConditionTrigger = 1
            mhvps_hvon = 4
            aps_hvon = 1
            aps_swon = 16
            bps_hvon = 2
            bps_swon = 8
            InputSignals = {
                Time = {
                    DataSource = DDB1
                    Type = uint32
                }
                PLC_ON = {
                    DataSource = DDB1
                    Type = uint32
                }
                MHVPS_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_HVON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_SWON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_HVON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_SWON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                SHOTLEN = {
                    DataSource = DDB1
                    Type = uint32
                }
                StopRequest = {
                	DataSource = DDB1
                	Type = uint32
                }
                MODE_SHOTLEN_FLAG = {
                    DataSource = DDB1
                    Type = uint32
                }
                SHORT_PULSE_MODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                //Add 20210120
                MHVPS_MODSW = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                //Add 20210121
                DO_REV6 = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }

            }
            OutputSignals = {
                RTSMValue = {
                    DataSource = DDB1
                    Type = uint32
                    Trigger = 1
                }
                BEAM_ON_STAT = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                HVARMED = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                HVINJECTION = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                RFON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BeamONTime = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                RFONTime = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                SHOT_ID = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                //Added 20201117
                APS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                APS_SWON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BPS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BPS_SWON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                MHVPS_HVON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                NI6259Value = {
                    DataSource = NI6259
                    //DataSource = DDB1
                    Type = uint32
                    Trigger = 1
                }
                NI6528P3Value = {
                    DataSource = NI6528P3
                    //DataSource = DDB1
                    Type = uint8
                }
                NI6528P4Value = {
                    DataSource = NI6528P4
                    //DataSource = DDB1
                    Type = uint8
                }
            }
        }
        +GAMSDNRealTimeStateMachine = {
            Class = JASDNRTStateMachineGAM
            ConditionTrigger = 1
            mhvps_hvon = 4
            aps_hvon = 1
            aps_swon = 16
            bps_hvon = 2
            bps_swon = 8
            InputSignals = {
                Time = {
                    DataSource = DDB1
                    Type = uint32
                }
                PLC_ON = {
                    DataSource = DDB1
                    Type = uint32
                }
                MHVPS_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_HVON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_SWON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_HVON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_SWON_DT = {
                    DataSource = DDB1
                    Type = uint32
                }
                SHOTLEN = {
                    DataSource = DDB1
                    Type = uint32
                }
                StopRequest = {
                	DataSource = DDB1
                	Type = uint32
                }
                MODE_SHOTLEN_FLAG = {
                    DataSource = DDB1
                    Type = uint32
                }
                Command = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint16
                }

            }
            OutputSignals = {
                RTSMValue = {
                    DataSource = DDB1
                    Type = uint32
                    Trigger = 1
                }
                BeamON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                HVARMED = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                HVINJECTION = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                RFON = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                BeamONTime = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                RFONTime = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
                SHOT_ID = {
                    DataSource = RealTimeThreadAsyncBridge
                    Type = uint32
                }
            }
        }

        //Terminal Interface reads three inputs.
        // INPUTs: StateMahine Value, NI6528P3Value and NI6528P4Value
        // OUTPUTs: Each NIxxx data sources.
        +terminalInterfaceGAM = {
            Class = JATerminalInterfaceGAM
            mhvps_hvon_term = 4
            aps_hvon_term = 1
            aps_swon_term = 16
            bps_hvon_term = 2
            bps_swon_term = 8
            InputSignals = {
                MHVPS_HVON = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_HVON = {
                    DataSource = DDB1
                    Type = uint32
                }
                APS_SWON = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_HVON = {
                    DataSource = DDB1
                    Type = uint32
                }
                BPS_SWON = {
                    DataSource = DDB1
                    Type = uint32
                }
                SHORT_PULSE_MODE = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                //Input signals about HW terminal.
                RTSMValue = {
                    DataSource = DDB1
                    Type = uint32
                }
                NI6528P3CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
                NI6528P4CurrentValue = {
                    DataSource = DDB1
                    Type = uint8
                }
            }
            OutputSignals = {
                NI6259Value = {
                    DataSource = NI6259
                    //DataSource = DDB1
                    Type = uint32
                    Trigger = 1
                }
                NI6528P3Value = {
                    DataSource = NI6528P3
                    //DataSource = DDB1
                    Type = uint8
                }
                NI6528P4Value = {
                    DataSource = NI6528P4
                    //DataSource = DDB1
                    Type = uint8
                }
            }
        }

        // Switching AO port source between internal variable and EPICS PV.
        +choiseGAM = {
            Class = JASourceChoiseGAM
            numberOfPVs = 5
            InputSignals = {
                BPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                BPS_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                BPS_MM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }
                
                APS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                APS_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                APS_MM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }

                MHVPS_REF = {
                    DataSource = DDB1
                    Type = float32
                }
                MHVPS_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                MHVPS_MM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }

                MCPS_TRG_CURR_SET = {
                    DataSource = DDB1
                    Type = float32
                }
                MCPS_TRG_CURR_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                MCPS_MM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }

                GCPS_TRG_CURR_SET = {
                    DataSource = DDB1
                    Type = float32
                }
                GCPS_TRG_CURR_MANUAL = {
                    DataSource = EPICSCAInput
                    Type = float32
                }
                GCPS_MM = {
                    DataSource = EPICSCAInput
                    Type = uint32
                }

            }
            OutputSignals = {
                BPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                APS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                MHVPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                MCPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
                GCPS_OUT = {
                    DataSource = DDB1
                    Type = float32
                }
            }
        }

        //debug
        +debugTimerGAM = {
            Class = IOGAM
            InputSignals = {
                Time1kHz = {
                    DataSource = DDB1
                    Type = uint32
                }
                TimeSDN = {
                    DataSource = DDB1
                    Type = uint32
                }
                Time = {
                    DataSource = DDB1
                    Type = uint32
                }
                Time1Hz = {
                    DataSource = DDB1
                    Type = uint32
                }

            }
            OutputSignals = {
                T1_time = {
                    DataSource = Display
                    Type = uint32
                }
                T2_time = {
                    DataSource = Display
                    Type = uint32
                }
                T3_time = {
                    DataSource = Display
                    Type = uint32
                }
                T4_time = {
                    DataSource = Display
                    Type = uint32
                }
            }
        }
        +GAMExecTime = {//debug
            Class = IOGAM
            InputSignals = {
                GAMEPICSCA_ExecTime = {
                    DataSource = Timings
                    Type = uint32
                }
                StopRequestGAM_ExecTime = {
                    DataSource = Timings
                    Type = uint32
                }
                ModeLimitGAM_ExecTime = {
                    DataSource = Timings
                    Type = uint32
                }
                NI6528P3GAM_ExecTime = {
                    DataSource = Timings
                    Type = uint32
                }
                terminalInterfaceGAM_ExecTime = {
                    DataSource = Timings
                    Type = uint32
                }
                GAMRealTimeStateMachine_ExecTime = {
                    DataSource = Timings
                    Type = uint32
                }

            }
            OutputSignals = {
                GAMEPICSCA_ExecTime = {
                    DataSource = Display
                    Type = uint32
                }
                StopRequestGAM_ExecTime = {
                    DataSource = Display
                    Type = uint32
                }
                ModeLimitGAM_ExecTime = {
                    DataSource = Display
                    Type = uint32
                }
                NI6528P3GAM_ExecTime = {
                    DataSource = Display
                    Type = uint32
                }
                terminalInterfaceGAM_ExecTime = {
                    DataSource = Display
                    Type = uint32
                }
                GAMRealTimeStateMachine_ExecTime = {
                    DataSource = Display
                    Type = uint32
                }
            }
        }

    }
    +Data = {
        Class = ReferenceContainer
        DefaultDataSource = DDB1
        +DDB1 = {
            Class = GAMDataSource
            AllowNoProducers = 1
            ResetUnusedVariablesAtStateChange = 0
        }
        // Timer for thread 1 (Normal RT state execution cycle.)
        +Timer1kHz = {
            Class = LinuxTimer
            SleepNature = "Busy" 
            SleepPercentage = 40
            ExecutionMode = RealTimeThread
            CPUMask = 0x100
            Signals = {
                Counter = {
                    Type = uint32
                }
                Time = {
                    Type = uint32
                }
            }
        }
        +TimerSDN = {
            Class = LinuxTimer
            SleepNature = "Busy" 
            SleepPercentage = 40
            ExecutionMode = RealTimeThread
            CPUMask = 0x200
            Signals = {
                Counter = {
                    Type = uint32
                }
                Time = {
                    Type = uint32
                }
            }
        }
        +Timer10Hz = {
            Class = LinuxTimer
            SleepNature = "Busy" 
            SleepPercentage = 40
            ExecutionMode = RealTimeThread
            CPUMask = 0x800
            Signals = {
                Counter = {
                    Type = uint32
                }
                Time = {
                    Type = uint32
                }
            }
        }     
        // Timer for thread 3 (RTStateMachineGAM execution cycle.)
        +Timer = {
            Class = LinuxTimer
            SleepNature = "Busy"
            SleepPercentage = 40
            ExecutionMode = RealTimeThread
            CPUMask = 0x400
            Signals = {
                Counter = {
                    Type = uint32
                }
                Time = {
                    Type = uint32
                }
            }
        }

        +Timings = {
            Class = TimingDataSource
        }
        +Display = {
            Class = LoggerDataSource
        }
        // for data exechange between threads.
        +RealTimeThreadAsyncBridge = {
            Class = RealTimeThreadAsyncBridge
            NumberOfBuffers = 20
        }
        // for access ECPIS PV.
        +EPICSCAInput = {
            Class = "EPICSCA::EPICSCAInput"
            CPUMask = "0x100" //change from 200
            StackSize = "10000000"
            Signals = {
                // PV for manually setting 
                BPS_MM = {
                    PVName = "EC-GN-P01-PB1F:STAT-MANM"
                    Type = uint32
                }
                BPS_MANUAL = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-EREF-MSP"
                    Type = float32
                }
                APS_MM = {
                    PVName = "EC-GN-P01-PA1F:STAT-MANM"
                    Type = uint32
                }
                APS_MANUAL = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-EREF-MSP"
                    Type = float32
                }
                MHVPS_MANUAL = {
                    PVName = "EC-GN-P01-PMF:PSU0000-EREF-MSP"
                    Type = float32
                }
                MHVPS_MM = {
                    PVName = "EC-GN-P01-PMF:STAT-MANM"
                    Type = uint32
                }
                // Analog Input PVs.
                GYA_BPS_MESVOLT = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_BPS_MESVOLT = {
                    PVName = "EC-GN-P01-PB2F:PSU2000-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_BPS_MESCURR = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-IT"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_BPS_MESCURR = {
                    PVName = "EC-GN-P01-PB2F:PSU2000-IT"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_APS_MESVOLT = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_APS_MESVOLT = {
                    PVName = "EC-GN-P01-PA2F:PSU4000-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_APS_MESCURR = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-IT"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_APS_MESCURR = {
                    PVName = "EC-GN-P01-PA2F:PSU4000-IT"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_ARC1_MESVOLT = {
                    PVName = "EC-GN-P01-GAF:MOE2810-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_ARC1_MESVOLT = {
                    PVName = "EC-GN-P01-GBF:MOE2810-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_ARC1_MESCURR = {
                    PVName = "EC-GN-P01-GAF:MOE2820-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_ARC1_MESCURR = {
                    PVName = "EC-GN-P01-GBF:MOE2820-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_ARC2_MESVOLT = {
                    PVName = "EC-GN-P01-GAF:MOE2830-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_ARC2_MESVOLT = {
                    PVName = "EC-GN-P01-GBF:MOE2830-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_ARC2_MESCURR = {
                    PVName = "EC-GN-P01-GAF:MRF2910-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_ARC2_MESCURR = {
                    PVName = "EC-GN-P01-GBF:MRF2910-ET"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_MHVPS_MESVOLT = {
                    PVName = "EC-GN-P01-PMF:PSU0000-ET-GA"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_MHVPS_MESVOLT = {
                    PVName = "EC-GN-P01-PMF:PSU0000-ET-GB"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYA_MHVPS_MESCURR = {
                    PVName = "EC-GN-P01-PMF:PSU0000-IT-GA"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GYB_MHVPS_MESCURR = {
                    PVName = "EC-GN-P01-PMF:PSU0000-IT-GB"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }

                //Digital Input PVs in Signal-Variable tab.
                APS_READY = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-YSTA"
                    Type = uint32
                } 
                GYA_APS_FLT = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-YFLT"
                    Type = uint32
                }
                GYB_APS_FLT = {
                    PVName = "EC-GN-P01-PA2F:PSU4000-YFLT"
                    Type = uint32
                }
                BPS_READY = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-YSTA"
                    Type = uint32
                }
                GYA_BPS_FLT = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-YFLT"
                    Type = uint32
                }
                GYB_BPS_FLT = {
                    PVName = "EC-GN-P01-PB2F:PSU2000-YFLT"
                    Type = uint32
                }
                MHVPS_OV = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-YFLT-OC"
                    Type = uint32
                }
                MHVPS_OC = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-YFLT-OV"
                    Type = uint32
                }
                MHVPS_FLT = {
                    PVName = "EC-GN-P01-PMF:PSU0000-YFLT"
                    Type = uint32
                }
                MHVPS_READY = {
                    PVName = "EC-GN-P01-PMF:PSU0000-TYSTA"
                    Type = uint32
                }
                MHVPS_MODON = {
                    PVName = "EC-GN-P01-GPF:PSU0000-YSTA-MOD"
                    Type = uint32
                }
                MIS_ITL = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-YTRP"
                    Type = uint32
                }
                MISB_ITL = {
                    PVName = "EC-GN-P01-GBFP:FMC4310-YTRP"
                    Type = uint32
                }
                PLC_ITL = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTRP"
                    Type = uint32
                }
                PLC_STANDBY = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-ST1R"
                    Type = uint32
                }
                PLC_READY = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-ST2R"
                    Type = uint32
                }
                PLC_ON = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-ST3R"
                    Type = uint32
                }
                PLC_MODE1 = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-MD1"
                    Type = uint32
                }
                PLC_MODE2 = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-MD2"
                    Type = uint32
                }
                PLC_MODE3 = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-MD3"
                    Type = uint32
                }
                PLC_MODE4 = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YTS-MD4"
                    Type = uint32
                }
                PLC_PERMIT = {
                    PVName = "EC-GN-P01-GPS:PLC4110-CON-GY1PRM"
                    Type = uint32
                }
                PLC_SELECT = {
                    PVName = "EC-GN-P01-GPS:PLC4110-CON-OPGY1"
                    Type = uint32
                }
                PLC_SYNCMODE = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YSTA-MPSS"
                    Type = uint32
                }
                PLC_CCPSON = {
                    PVName = "EC-GN-P01-GPS:PLC4110-YON-CCPS1"
                    Type = uint32
                }
                EXT_TRIG = {
                    PVName = "EC-GN-P01-GAF:DIO4900-YON"
                    Type = uint32
                }

                //Digital Output PVs in Variables-signal tab
                APS_HVON = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-CON-HV"
                    Type = uint32
                }
                APS_SWON = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-CON-SW"
                    Type = uint32
                }
                APS_STOP = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-CTRP"
                    Type = uint32
                }
                BPS_HVON = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-CON-HV"
                    Type = uint32
                }
                BPS_SWON = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-CON-SW"
                    Type = uint32
                }
                BPS_STOP = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-CTRP"
                    Type = uint32
                }
                BEAM_ON_STAT = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-YSTA-GAOP"
                    Type = uint32
                }
                DO_REV5 = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-RV5"
                    Type = uint32
                }
                DO_REV6 = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-RV6"
                    Type = uint32
                }
                DO_REV7 = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-RV7"
                    Type = uint32
                }
                DO_REV8 = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-RV8"
                    Type = uint32
                }
                MHVPS_HVON = {
                    PVName = "EC-GN-P01-PMF:PSU0000-CON-SW"
                    Type = uint32
                }
                MHVPS_STOP = {
                    PVName = "EC-GN-P01-PMF:PSU0000-COFF"
                    Type = uint32
                }
                MHVPS_MODSW = {
                    PVName = "EC-GN-P01-PMF:PSU0000-CON-MOD"
                    Type = uint32
                }
                PCF_FLT = {
                    PVName = "EC-GN-P01-GPF:PCF4210-CTRP"
                    Type = uint32
                }
                HVARMED = {
                    PVName = "EC-GN-P01-GPF:PCF4210-YTS-GA1"
                    Type = uint32
                }
                HVINJECTION = {
                    PVName = "EC-GN-P01-GPF:PCF4210-YTS-GA2"
                    Type = uint32
                }
                RFON = {
                    PVName = "EC-GN-P01-GPF:PCF4210-YTS-GA3"
                    Type = uint32
                }
                FHPS_RU = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-YTS-RUP"
                    Type = uint32
                }
                SCM_RU = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-YTS-RUP"
                    Type = uint32
                }
                SCM_RD = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-YTS-RDOWN"
                    Type = uint32
                }
                CCPS_IN_OPERATION = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-TR"
                    Type = uint32
                }
                //Input PVs in Variables-Operation tab.
                PREP_MODE = {
                    PVName = "EC-GN-P01-GAF:STAT-PREP-MODE"
                    Type = uint32
                }
                SHORT_PULSE_MODE = {
                    PVName = "EC-GN-P01-GAF:STAT-SHORT-PULSE"
                    Type = uint32
                }

                MHVPS_DT = {
                    PVName = "EC-GN-P01-PMF:STAT-DT-HVON"
                    Type = uint32
                }
                APS_HVON_DT = {
                    PVName = "EC-GN-P01-PA1F:STAT-DT-HVON"
                    Type = uint32
                }
                APS_SWON_DT = {
                    PVName = "EC-GN-P01-PA1F:STAT-DT-SWON"
                    Type = uint32
                }
                BPS_HVON_DT = {
                    PVName = "EC-GN-P01-PB1F:STAT-DT-HVON"
                    Type = uint32
                }
                BPS_SWON_DT = {
                    PVName = "EC-GN-P01-PB1F:STAT-DT-SWON"
                    Type = uint32
                }
                SHOTLEN = {
                    PVName = "EC-GN-P01-GAF:STAT-DT-SHOTLEN"
                    Type = uint32
                }

                MD1_SHOTLEN_LIM = {
                    PVName = "EC-GN-P01-GPF:STAT-MD1-LIM"
                    Type = uint32
                }
                MD2_SHOTLEN_LIM = {
                    PVName = "EC-GN-P01-GPF:STAT-MD2-LIM"
                    Type = uint32
                }
                MD3_SHOTLEN_LIM = {
                    PVName = "EC-GN-P01-GPF:STAT-MD3-LIM"
                    Type = uint32
                }
                MD4_SHOTLEN_LIM = {
                    PVName = "EC-GN-P01-GPF:STAT-MD4-LIM"
                    Type = uint32
                }

                FHPS_MANM = {
                    PVName = "EC-GN-P01-GAF-FHPS:STAT-MANM"
                    Type = uint32
                }

                CSV_LOAD = {
                    PVName = "EC-GN-P01-GAF:STAT-CSV-LOAD"
                    Type = uint32
                }
                CSV_NAME = {
                    PVName = "EC-GN-P01-GAF:STAT-CSV-NAME"
                    Type = char8
                    NumberOfElements = 40
                }
                RESET_FLT = {
                    PVName = "EC-GN-P01-GPF:STAT-RST-FLT"
                    //PVName = "EC-GN-P01-GPS-MEM:CMD-CONALARMRESET-HMI"
                    Type = uint32
                }

                //Input PVs in Variables-JASTEC tab.
                MCPS_ACT_SP = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-ACT-SET-MI"
                    Type = uint32
                }
                MCPS_TRG_CURR_MANUAL = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-TRG-CURR-SET-MI"
                    Type = float32
                }
                MCPS_ACT_RB = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-ACT-RB"
                    Type = uint32
                }
                MCPS_CURR_RB = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-TRG-CURR-RB"
                    Type = uint32
                }
                GYA_MCPS_CURR_MON = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-CURR-MON"
                    Type = float32
                }
                GYB_MCPS_CURR_MON = {
                    PVName = "EC-GN-P01-GBF-MCPS:PSU2120-CURR-MON"
                    Type = float32
                }
                MCPS_VOLT_MON = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-VOLT-MON"
                    Type = uint32
                }
                MCPS_SWP_RB = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-SWP-RB"
                    Type = uint32
                }
                MCPS_SWP_LIM = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-SWP-LIM"
                    Type = uint32
                }
                MCPS_ERR = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-ERR"
                    Type = uint32
                }
                MCPS_MM = {
                    PVName = "EC-GN-P01-GAF-MCPS:STAT-MANM"
                    Type = uint32
                }
                //GCPS PVs
                GCPS_ACT_SP = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-ACT-SP-MI"
                    Type = uint32
                }
                GCPS_TRG_CURR_MANUAL = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-TRG-CURR-SET-MI"
                    Type = float32
                }
                GCPS_ACT_RB = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-ACT-RB"
                    Type = uint32
                }
                GCPS_CURR_RB = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-TRG-CURR-RB"
                    Type = uint32
                }
                GYA_GCPS_CURR_MON = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-CURR-MON"
                    Type = float32
                }
                GYB_GCPS_CURR_MON = {
                    PVName = "EC-GN-P01-GBF-GCPS:PSU2130-CURR-MON"
                    Type = float32
                }
                GCPS_VOLT_MON = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-VOLT-MON"
                    Type = uint32
                }
                GCPS_SWP_RB = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-SWP-RB"
                    Type = uint32
                }
                GCPS_SWP_LIM = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-SWP-LIM"
                    Type = uint32
                }
                GCPS_ERR = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-ERR"
                    Type = uint32
                }
                GCPS_MM = {
                    PVName = "EC-GN-P01-GAF-GCPS:STAT-MANM"
                    Type = uint32
                }
                //Input PVs in Variables-kikusui tab.
                FHPS_REM_RB = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-REM-RB"
                    Type = uint32
                }
                FHPS_OUTON_RB = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-OUTON-RB"
                    Type = uint32
                }
                FHPS_CURR_RB = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-CURR-RB"
                    Type = uint32
                }
                FHPS_ACV_RB = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-ACV-RB"
                    Type = uint32
                }
                FHPS_FRQ_RB = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-FRQ-RB"
                    Type = uint32
                }
                FHPS_SOUR_ON_RB = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-SOUR-ON-RB"
                    Type = uint32
                }
                FHPS_MEAS_ACV = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-MEAS-ACV"
                    Type = float32
                }
                GYA_FHPS_MEAS_ACI = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-MEAS-ACI"
                    Type = float32
                }
                GYB_FHPS_MEAS_ACI = {
                    PVName = "EC-GN-P01-GBF-FHPS:PSU2610-MEAS-ACI"
                    Type = float32
                }
                FHPS_MEAS_ACP = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-MEAS-ACP"
                    Type = uint32
                }
                FHPS_MEAS_FRQ = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-MEAS-FRQ"
                    Type = uint32
                }
                FHPS_ERR = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-ERROR"
                    Type = uint32
                }
                FHPS_AUTO_TAGV = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-AUTO-TAGV"
                    Type = float32
                }
                FHPS_AUTO_TIME = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-AUTO-RU-TIME"
                    Type = float32
                }
                FHPS_AUTO_START = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-AUTO-START"
                    Type = uint32
                }

                CCPS_REMLOC_RB = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-REMLOC-RB"
                    Type = uint32
                }
                CCPS_OUTON_RB = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-OUTON-RB"
                    Type = uint32
                }
                CCPS_CURR_RB = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-CURR-RB"
                    Type = uint32
                }
                CCPS_DCV_RB = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-DCV-RB"
                    Type = uint32
                }
                CCPS_RANG_RB = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-RANG-RB"
                    Type = uint32
                }
                CCPS_SOUR_ON_RB = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-SOUR-ON-RB"
                    Type = uint32
                }
                CCPS_MEAS_DCV = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-MEAS-DCV"
                    Type = uint32
                }
                GYA_CCPS_MEAS_DCI = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-MEAS-DCI"
                    Type = float32
                }
                GYB_CCPS_MEAS_DCI = {
                    PVName = "EC-GN-P01-GBF-CCPS:PSU2320-MEAS-DCI"
                    Type = float32
                }
                CCPS_MEAS_DCP = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-MEAS-DCP"
                    Type = uint32
                }
                CCPS_ERR = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-ERROR"
                    Type = uint32
                }
                CCPS_OUTPUT_AMP = {
                    PVName = "EC-GN-P01-GAF-CCPS:STAT-AMP"
                    Type = float32
                }
                CCPS_OUTPUT_FREQ = {
                    PVName = "EC-GN-P01-GAF-CCPS:STAT-FREQ"
                    Type = float32
                }
                CCPS_OUTPUT_OFFS = {
                    PVName = "EC-GN-P01-GAF-CCPS:STAT-OFFS"
                    Type = float32
                }
                //PXI Board status PVs
                PXI6259_0 = {
                    PVName = "EC-GN-HWCF:6259-0-STATUS"
                    Type = uint32
                }
                PXI6259_1 = {
                    PVName = "EC-GN-HWCF:6259-1-STATUS"
                    Type = uint32
                }
                PXI6528_0 = {
                    PVName = "EC-GN-HWCF:6528-0-STATUS"
                    Type = uint32
                }
                PXI6528_1 = {
                    PVName = "EC-GN-HWCF:6528-1-STATUS"
                    Type = uint32
                }
                PXI6368_0 = {
                    PVName = "EC-GN-HWCF:6368-0-STATUS"
                    Type = uint32
                }
                PXI6368_1 = {
                    PVName = "EC-GN-HWCF:6368-1-STATUS"
                    Type = uint32
                }
            }
        }
        +EPICSCAOutput = {
            Class = "EPICSCA::EPICSCAOutput"
            CPUMask = "0x100" //change from 0x200
            StackSize = "10000000"
            NumberOfBuffers = 2
            Signals = {
                PCF_STATE = {
                    PVName = "EC-GN-P01-GAF:STAT-SM"
                    Type = uint32
                }
                //Analog Output PVs in Variables-signal tab.
                FHPS_REF = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-EREF"
                    Type = float32
                }
                BPS_REF = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-EREF"
                    Type = float32
                }
                APS_REF = {
                    PVName = "EC-GN-P01-PA1F:STAT-EREF-CONV.A"
                    Type = float32
                }
                MHVPS_REF = {
                    PVName = "EC-GN-P01-PMF:STAT-EREF-CALC.A"
                    Type = float32
                }

                //Digital Output PVs in Variables-signal tab.
                APS_STOP = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-CTRP"
                    Type = uint32
                }

                BPS_STOP = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-CTRP"
                    Type = uint32
                }

                BEAM_ON_STAT = {
                    PVName = "EC-GN-P01-GAFP:FMC4310-YSTA-GAOP"
                    Type = uint32
                }

                MHVPS_STOP = {
                    PVName = "EC-GN-P01-PMF:PSU0000-COFF"
                    Type = uint32
                }
                PCF_FLT = {
                    PVName = "EC-GN-P01-GPF:PCF4210-CTRP"
                    Type = uint32
                }
                HVARMED = {
                    PVName = "EC-GN-P01-GPF:PCF4210-YTS-GA1"
                    Type = uint32
                }
                HVINJECTION = {
                    PVName = "EC-GN-P01-GPF:PCF4210-YTS-GA2"
                    Type = uint32
                }
                RFON = {
                    PVName = "EC-GN-P01-GPF:PCF4210-YTS-GA3"
                    Type = uint32
                }

                //Output PVs in Variables-operation tab.
                MHVPS_PREP_WF = {
                    PVName = "EC-GN-P01-PMF:STAT-PREP-WF"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1

                }
                BPS_PREP_WF = {
                    PVName = "EC-GN-P01-PB1F:STAT-PREP-WF"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                APS_PREP_WF = {
                    PVName = "EC-GN-P01-PA1F:STAT-PREP-WF"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                FHPS_PREP_WF = {
                    PVName = "EC-GN-P01-GAF-FHPS:STAT-PREP-WF"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                MCPS_PREP_WF = {
                    PVName = "EC-GN-P01-GAF-MCPS:STAT-PREP-WF"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                GCPS_PREP_WF = {
                    PVName = "EC-GN-P01-GAF-GCPS:STAT-PREP-WF"
                    Type = float32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                PREP_TIME_WF = {
                    PVName = "EC-GN-P01-GAF:STAT-PREP-TIME-WF"
                    Type = int32
                    NumberOfElements = 8000
                    NumberOfDimensions = 1
                }
                BEAM_ON_TIME = {
                    PVName = "EC-GN-P01-GAF:STAT-BEAMON-TIME"
                    Type = uint32
                }
                ELAPSED_TIME = {
                    PVName = "EC-GN-P01-GAF:STAT-ELAPSED"
                    Type = uint32
                }
                SHOT_ID = {
                    PVName = "EC-GN-P01-GAF:STAT-SHOT-ID"
                    Type = uint32
                }

                CSV_LOADED = {
                    PVName = "EC-GN-P01-GAF:STAT-CSV-LOADED"
                    Type = uint32
                }
                CSV_ERR = {
                    PVName = "EC-GN-P01-GAF:STAT-CSV-ERR"
                    Type = uint32
                }

                //Output PVs in Variables-jastec tab.
                MCPS_TRG_CURR_SET = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-TRG-CURR-SET-MO"
                    Type = float32
                }
                MCPS_ACT_SP = {
                    PVName = "EC-GN-P01-GAF-MCPS:PSU2120-ACT-SP-MO"
                    Type = uint32
                }
                GCPS_TRG_CURR_SET = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-TRG-CURR-SET-MO"
                    Type = float32
                }
                GCPS_ACT_SP = {
                    PVName = "EC-GN-P01-GAF-GCPS:PSU2130-ACT-SP-MO"
                    Type = uint32
                }

                //Output PVs in Variables-kikusui tab.
                CCPS_REF = {
                    PVName = "EC-GN-P01-GAF-CCPS:PSU2320-EREF"
                    Type = float32
                }
                FHPS_AUTO_STAT = {
                    PVName = "EC-GN-P01-GAF-FHPS:PSU2610-AUTO-STAT"
                    Type = uint32
                }
                //Add 20201117
                APS_HVON = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-CON-HV"
                    Type = uint32
                }
                APS_SWON = {
                    PVName = "EC-GN-P01-PA1F:PSU3000-CON-SW"
                    Type = uint32
                }
                BPS_HVON = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-CON-HV"
                    Type = uint32
                }
                BPS_SWON = {
                    PVName = "EC-GN-P01-PB1F:PSU1000-CON-SW"
                    Type = uint32
                }
                MHVPS_HVON = {
                    PVName = "EC-GN-P01-PMF:STAT-HVON-CALC.A"
                    Type = uint32
                }
            }
        }
        // for ESDN packet subscription/publication.
        +SDNSubCommands = {
            Class = SDN::SDNSubscriber
            Topic = ECPC2SCUJA
            Interface = enp27s0f0 
            CPUs = 0x200 //change from 100
            Locked = 1
            Timeout = 2
            Signals = {
                Header = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 48
                }
                ESDNHeaderVersionId = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNHeaderSize = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNStatus = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNDoNotUse = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNTime = {
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                Command = {
                    Type = uint16
                    NumberOfDimensions = 1
                    NumberOfElements = 64
                }
            }
        }
        +SDNReply = {
            Class = SDN::SDNPublisher
            Topic = SCUJA2ECPC
            Interface = enp27s0f0 
            CPUs = 0x200 //changed from 0x100
            Locked = 1
            Signals = {
                Header = {
                     Type = uint8
                     NumberOfElements = 48
                }
                ESDNHeaderVersionId = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNHeaderSize = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNStatus = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNDoNotUse = {
                    Type = uint8
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ESDNTime = {
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ReplyStatus = {
                    Type = uint16
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                ReplyWaveformAck = {
                    Type = uint16
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                //Status (26Bytes?) is not assigned
                //GyrotronA measurements
                //56Bytes are used as Gyrotron1 Measurements (verified on 2020/10/22)
                GYA_MHVPS_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_MHVPS_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_BPS_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_BPS_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_APS_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_APS_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_ARC1_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_ARC1_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_ARC2_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_ARC2_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_MCPS_CURR_MON = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_GCPS_CURR_MON = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_FHPS_MEAS_ACI = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYA_CCPS_MEAS_DCI = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                //GyrotronB measurements
                GYB_MHVPS_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_MHVPS_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_BPS_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_BPS_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_APS_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_APS_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_ARC1_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_ARC1_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_ARC2_MESVOLT = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_ARC2_MESCURR = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_MCPS_CURR_MON = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_GCPS_CURR_MON = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_FHPS_MEAS_ACI = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
                GYB_CCPS_MEAS_DCI = {
                    Type = float32
                    NumberOfDimensions = 1
                    NumberOfElements = 1
                }
            }
        }

        // Direct HW accesses. Follwing device/port assignment must be consistent with actual wiring.
        // NI6259.0
        // APS_SWON BoardId=0, PortId=3.0
        +NI6259 = {
            Class = NI6259::NI6259DIO
            DeviceName = "/dev/pxi6259"
            BoardId = 1
            Signals = {
                NI6259Value = {
                    Type = uint32
                    Mask = 0xFF
                    PortId = 0
                }
            }
        }

        //NI6528 digital output has logic low == 0 == close relay. ((See Driver Manual.)
        //When the program send ON signal, this program writes 0 on the data source.
        +NI6528P3 = {
            Class = NI6528
            DeviceName = "/dev/pxi6528.1"
            Port = 3
            NI6528P3Value = {
                NI6528P3Value = {
                    Type = uint8
                }
            }
        } 
        //P3.0 APS_HVON
        //P3.1 APS_SWON
        //P3.2 APS_Shutdown
        //P3.3 BPS_HVON
        //P3.4 BPS_SWON
        //P3.5 BPS_Shutdown
        //P3.6 GY1_Beam_ON_status
        //P3.7 RV5 _cRIO

        +NI6528P4 = {
            Class = NI6528
            DeviceName = "/dev/pxi6528.1"
            Port = 4
            NI6528P4Value = {
                NI6528P4Value = {
                    Type = uint8
                }
            }
        } 
        //P4.0 RV6 _cRIO
        //P4.1 RV7 _cRIO
        //P4.2 RV8 _cRIO
        //P4.3 MHVPS_HVON
        //P4.4 MHVPS_Shutdown
        //P4.5 MHVPS_MOD
        //P4.6 PCF_FLT
        //P4.7 HVArmed

        +NI6528P5 = {
            Class = NI6528
            DeviceName = "/dev/pxi6528.1"
            Port = 5
            NI6528P5Value = {
                NI6528P5Value = {
                    Type = uint8
                }
            }
        } 
        //P5.0 HVInjection
        //P5.1 RFON
        //P5.2 FHPS_Rampup_complete
        //P5.3 SCM_RU_Complete
        //P5.4 SCM_RD_Complete
        //P5.5 CCPS_IN_OPERATION
        //P5.6 None
        //P5.7 None

    }
    +States = {
        Class = ReferenceContainer
        +Disabled = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM GoErrorGAM InDisabledGAM
                                GoWaitStandbyGAM choiseGAM MCPSGAM GCPSGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM}
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM 
                                NI6528P3GAM NI6528P4GAM NI6528P5GAM
                                NI6528P3PV2PortGAM NI6528P4PV2PortGAM NI6528P5PV2PortGAM 
                                NI6528P3WriteGAM NI6528P4WriteGAM }
                    CPUs = 0x400
                }
            }
        }
        +WaitStandby = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM FHPSSetpointGAM FHPSRampupGAM InWaitStandbyGAM
                                choiseGAM MCPSGAM GCPSGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                GoDisabledGAM GoWaitReadyGAM GoErrorGAM }
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM 
                                NI6528P3GAM NI6528P4GAM NI6528P5GAM
                                NI6528P3PV2PortGAM NI6528P4PV2PortGAM NI6528P5PV2PortGAM 
                                NI6528P3WriteGAM NI6528P4WriteGAM }
                    CPUs = 0x400
                }
            }
        }
        +WaitReady = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM WFRecordGAM PreProgrammedGAM FHPSSetpointGAM FHPSRampupGAM InWaitReadyGAM
                                choiseGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                GoWaitPermitGAM GoWaitStandbyFromReadyGAM GoErrorGAM }
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM 
                                NI6528P3GAM NI6528P4GAM NI6528P5GAM
                                NI6528P3PV2PortGAM NI6528P4PV2PortGAM NI6528P5PV2PortGAM 
                                NI6528P3WriteGAM NI6528P4WriteGAM }
                    CPUs = 0x400
                }
            }
        }
        +WaitPermit = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM WFRecordGAM PreProgrammedGAM FHPSSetpointGAM FHPSRampupGAM InWaitPermitGAM
                                choiseGAM EPICSOutputGAM GoWaitReadyFromWaitPermitGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                GoWaitHVONGAM GoWaitHVON_PREP_GAM GoWaitHVON_SDN_GAM GoWaitHVON_SDN_PREP_GAM GoErrorGAM }
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM 
                                NI6528P3GAM NI6528P4GAM NI6528P5GAM
                                NI6528P3PV2PortGAM NI6528P4PV2PortGAM NI6528P5PV2PortGAM 
                                NI6528P3WriteGAM NI6528P4WriteGAM }
                    CPUs = 0x400
                }
            }
        }

        //Real-Time state for HVPS sequence timing control.
        +WaitHVON = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM FHPSSetpointGAM FHPSRampupGAM InWaitHVONGAM
                                choiseGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                writeBeamONStateGAM writeHVArmedStateGAM writeHVInjectionStateGAM writeRFONStateGAM 
                                writeBeamONTimeGAM writeRFONTimeGAM 
                                FromWaitHVONToWaitStandby FromWaitHVONToWaitPermit GoErrorGAM }
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM GAMEPICSCA StopRequestGAM ModeLimitGAM 
                                NI6528P3GAM NI6528P4GAM 
                                GAMRealTimeStateMachine NI6528P5GAM NI6528P5PV2PortGAM}
                    CPUs = 0x400
                }
//                +Thread4 = {
//                    Class = RealTimeThread
//                    Functions = {Timer10HzGAM GAMExecTime }
//                    CPUs = 0x800
//                }
            }
        }
        +WaitHVON_SDN = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM FHPSRampupGAM InWaitHVON_SDNGAM
                                choiseGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                writeBeamONStateGAM writeHVArmedStateGAM writeHVInjectionStateGAM writeRFONStateGAM 
                                writeBeamONTimeGAM writeRFONTimeGAM 
                                FromWaitHVONToWaitStandby FromWaitHVONToWaitPermit GoErrorGAM }
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM GAMEPICSCA StopRequestGAM ModeLimitGAM 
                                NI6528P3GAM NI6528P4GAM 
                                GAMSDNRealTimeStateMachine terminalInterfaceGAM NI6528P5GAM NI6528P5PV2PortGAM}
                    CPUs = 0x400
                }
            }
        }
        +WaitHVON_PREP = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM PreProgrammedGAM FHPSRampupGAM InWaitHVON_PREPGAM
                                choiseGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                writeBeamONStateGAM writeHVArmedStateGAM writeHVInjectionStateGAM writeRFONStateGAM 
                                writeBeamONTimeGAM writeRFONTimeGAM 
                                FromWaitHVONToWaitStandby FromWaitHVONToWaitPermit GoErrorGAM }
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM GAMEPICSCA StopRequestGAM ModeLimitGAM 
                                NI6528P3GAM NI6528P4GAM 
                                GAMRealTimeStateMachine NI6528P5GAM NI6528P5PV2PortGAM}
                    CPUs = 0x400
                }
            }
        }
        +WaitHVON_SDN_PREP = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM CCPSWaveformGAM PreProgrammedGAM FHPSRampupGAM InWaitHVON_SDN_PREPGAM
                                choiseGAM EPICSOutputGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                writeBeamONStateGAM writeHVArmedStateGAM writeHVInjectionStateGAM writeRFONStateGAM 
                                writeBeamONTimeGAM writeRFONTimeGAM 
                                FromWaitHVONToWaitStandby FromWaitHVONToWaitPermit GoErrorGAM}
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM GAMEPICSCA StopRequestGAM ModeLimitGAM 
                                NI6528P3GAM NI6528P4GAM 
                                GAMSDNRealTimeStateMachine terminalInterfaceGAM NI6528P5GAM NI6528P5PV2PortGAM}
                    CPUs = 0x400
                }
            }
        }

        +Error = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    Functions = {Timer1kHzGAM InErrorGAM PXI6368Error03GAM PXI6368Error04GAM PXI6259ErrorGAM PXIErrorGAM
                                ExitedHVArmedInjectionRFONGAM ResetPSsGAM 
                                FromErrorToWaitStandbyGAM ErrorGAM choiseGAM EPICSOutputGAM FHPSSetpointGAM FHPSRampupGAM CCPSWaveformGAM}
                    CPUs = 0x100
                }
                +Thread2 = {
                    Class = RealTimeThread
                    Functions = {TimeSDNGAM SDNCommandGAM SDNReplyGAM}
                    CPUs = 0x200
                }
                +Thread3 = {
                    Class = RealTimeThread
                    Functions = {Timer100kHzGAM 
                                NI6528P3GAM NI6528P4GAM NI6528P5GAM
                                NI6528P3PV2PortGAM NI6528P4PV2PortGAM NI6528P5PV2PortGAM 
                                NI6528P3WriteGAM NI6528P4WriteGAM }
                    CPUs = 0x400
                }
            }
        }
    }
    +Scheduler = {
        Class = GAMScheduler
        TimingDataSource = Timings
    }
}