#!/bin/sh  
# \
exec oagwish "$0" "$@"

# Test command
# /home/helios/BXYANG/operations/s35apps/bunchPurity/bpMonStartupBM

set auto_path [linsert $auto_path 0  /usr/local/oag/apps/lib/$env(HOST_ARCH)]
set auto_path [linsert $auto_path 0 /usr/local/oag/lib_patch/$env(HOST_ARCH)]
#APSDebugPath
APSStandardSetup
#APSSCRDefineVariables


# message window output "stdout"
proc SetMainStatus {text args} {     
    global mainStatus 
    set code ""
    APSParseArguments {code}
    set mainStatus "[clock format [clock seconds] -format %H:%M:%S] $text"
    switch $code {
        error -
        warning {
            bell
        }
        default {}
    }
    update      
}    


# Widgets design: Setup
proc CheckupFrame {widget args} {
    APSStrictParseArguments {parent}

    set w $parent$widget.frame
    APSFrame $widget -parent $parent \
      -label "Check Bunch Purity Monitor Hardware" 
    
    # executable command
    APSButton .checkup -parent $w \
      -text "Check Bunch Purity Monitor System Hardware" \
      -packOption "-side left" \
      -command {checkBPMonitor} \
      -contextHelp "Check bunch purity monitor detector, electronics for readiness."

    return
}


# Widgets design: Instruction
proc HowToFrame {widget args} {
    APSStrictParseArguments {parent}

    set w $parent$widget.frame
    APSFrame $widget -parent $parent \
      -label "Instructions for Resetting Bunch Purity Monitor Hardware" 
    
    # executable command
    APSButton .reboot -parent $w \
      -text "Reboot FPGA Processor" \
      -packOption "-side left" \
      -command {Instruction -device reboot} \
      -contextHelp "How to reboot the FPGA unit."

    APSButton .apdpower -parent $w \
      -text "Start APD HV Power Supply" \
      -packOption "-side left" \
      -command {Instruction -device apdpower} \
      -contextHelp "How to start Avalanche PhotoDiode high voltage power supply."

    APSButton .dcpower -parent $w \
      -text "Start preamplifier Power Supply" \
      -packOption "-side left" \
      -command {Instruction -device dcpower} \
      -contextHelp "How to start DC power supply."
 
    return
}


# Widgets design: Detector
proc SetupFrame {widget args} {
    global abortRun
    APSStrictParseArguments {parent}

    set w $parent$widget.frame
    APSFrame $widget -parent $parent \
      -label "Remotely Start Bunch Purity Monitor System Components" 
    
    # executable command
    APSButton .dcpower -parent $w \
      -text "1. Turn on power supplies" \
      -packOption "-side left" \
      -command {dcPower -action on; apdPower -action on} \
      -contextHelp "Turn on the APD preamplifier power supply."

    APSButton .openPS2 -parent $w \
      -text "2. Open shutters" \
      -packOption "-side left" \
      -command {openShutters} \
      -contextHelp "Open 35-BM photon shutter PS2 and safety shutters."

    APSButton .counter -parent $w \
      -text "3. Start pulse counter" \
      -packOption "-side left" \
      -command {pulseCounter -action on} \
      -contextHelp "Set up Struck pulse counter."

    APSButton .tscan -parent $w \
      -text "4. Set up FPGA" \
      -packOption "-side left" \
      -command {setupFPGA -action on} \
      -contextHelp "Set up FPGA unit and run delay time scan program to search for optimal phase."

    APSButton .bcg -parent $w \
      -text "5. Set up BCG" \
      -packOption "-side left" \
      -command {exec /home/helios/PHOTODIA/operations/s35apps/bunchPurity/bcgPatternSetup -powerUser 0 } \
      -contextHelp "Set up Bunch Clock Generator for bunch purity monitors."

    return
}


# Widgets design: Shutdown
proc ShutdownFrame {widget args} {
    global abortRun
    APSStrictParseArguments {parent}

    set w $parent$widget.frame
    APSFrame $widget -parent $parent \
      -label "Stop Bunch Purity Monitor System Components" 
    
    # executable command
    APSButton .dcpower -parent $w \
      -text "Turn off power supplies" \
      -packOption "-side left" \
      -command {dcPower -action off; apdPower -action off} \
      -contextHelp "Turn off the APD preamplifier power supply."

    APSButton .openPS2 -parent $w \
      -text "Close shutters" \
      -packOption "-side left" \
      -command {closeShutters} \
      -contextHelp "Close 35-BM photon shutter PS2 and safety shutters."

    APSButton .datalogger -parent $w \
      -text "Disable Data Logging" \
      -packOption "-side left" \
      -command {setVar -var loggingControl -value 0 -verbose 1} \
      -contextHelp "Clear data logger flag."

    APSButton .enabledatalogger -parent $w \
      -text "Enable Data Logging" \
      -packOption "-side left" \
      -command {setVar -var loggingControl -value 1 -verbose 1} \
      -contextHelp "Set data logger flag."

    return
}


#######################################################################
#
#	Set up Bunch Purity Monitor
#
#######################################################################


proc checkBPMonitor {args} {
    APSSetVarAndUpdate mainStatus "\nChecking Bunch Purity Monitor hardware for readiness."
    
	# Check 35-BM Front End shutters	
    set errCount [checkShutters]

	# Check APD power supply
    set moreErrCount [checkAPDPowerSupply]
    set errCount [expr $errCount + $moreErrCount]    

	# Check preamp power supply
    set moreErrCount [checkDCPowerSupply]
    set errCount [expr $errCount + $moreErrCount]    

	# Check pulse counter
    set moreErrCount [checkPulseCounter]
    set errCount [expr $errCount + $moreErrCount]    

    APSSetVarAndUpdate mainStatus "Checking complete. \nTotal number of errors = $errCount"
    return $errCount
}


proc checkShutters {args} {
    set wait 0
    APSParseArguments {wait}

    set errCount 0

	# Check Photon Shutter No. 1
    set ps1Status [getVar -var ps1Status]
    if {$ps1Status=="Closed"} {
      SetMainStatus "35BM Photon Shutter 1 Position = $ps1Status"
      SetMainStatus "Contact floor coordinates to get it opened."
      set errCount [expr $errCount + 2]
      return $errCount
    }

	# Check Photon Shutter No. 2 and wait for it to open
    set ps2Status [getVar -var ps2Status]
    if {$ps2Status=="Closed" && $wait > 0 } {
       # Watch shutter status
      for {set istep 1} {$istep <= $wait} {incr istep} {
        after 1000
        set ps2Status [getVar -var ps2Status ]
        if {$ps2Status=="Open"} { break }
      }
    }
    set ps2Status [getVar -var ps2Status]
    if {$ps2Status=="Closed" } {
      SetMainStatus "Shutters (PS2/SS) are CLOSED."
      set errCount [expr $errCount + 1]
    }

    if { $errCount<1 } { SetMainStatus "Photon Shutters PS1 and PS2 are OPEN. \ncheckShutters: Done." }
    return $errCount
}


proc checkAPDPowerSupply {args} {
    set wait 0
    APSParseArguments {wait}

    set errCount 0

	# Check power switch
    set apdPowerStatus [getVar -var apdPowerStatus ]
    if {$apdPowerStatus=="Off"} { 
      SetMainStatus "APD power supply is turned off."
      set errCount [expr $errCount + 1]
    } 

	# Check voltages
    set apdVoltSet [getVar -var apdVoltSet ]
    set apdVoltage [getVar -var apdVoltage ]
    if {[expr abs($apdVoltSet - $apdVoltage)]>1} { 
      if { $wait } {
        for {set istep 1} {$istep <= $wait} {incr istep} {
          SetMainStatus "APD power supply voltage = $apdVoltage, setpoint = $apdVoltSet."
          after 2000
          set apdVoltSet [getVar -var apdVoltSet ]
          set apdVoltage [getVar -var apdVoltage ]
          if {[expr abs($apdVoltSet - $apdVoltage)]<2} { break }
        }
      }
      if {[expr abs($apdVoltSet - $apdVoltage)]>1} { 
        SetMainStatus "APD power supply voltage disagrees witht the set point."
        set errCount [expr $errCount + 1]
      }
    }

	# Check current
    set apdCurrent [getVar -var apdCurrent ]
    if { $apdCurrent>0.000030 || $apdCurrent < 0.000010 } { 
      SetMainStatus "APD power supply current is out of normal range."
      set errCount [expr $errCount + 1]
    }

    if { $errCount<1 } { SetMainStatus "APD power supply is ready." }
    return $errCount
}


proc checkDCPowerSupply {args} {
    set errCount 0

	# Check power switch
    set dcPowerStatus [getVar -var dcPowerStatus ]
    if {$dcPowerStatus=="Off"} { 
      SetMainStatus "Preamplifier power supply is turned off."
      set errCount [expr $errCount + 1]
    } 

	# Check voltages
    set dcVoltSet [getVar -var dcVoltSet ]
    set dcVoltage [getVar -var dcVoltage ]
    if {[expr abs($dcVoltSet - $dcVoltage)]>1} { 
      SetMainStatus "Preamplifier power supply voltage disagrees witht the set point."
      set errCount [expr $errCount + 1]
    }

	# Check current
    set dcCurrent [getVar -var dcCurrent ]
    if { $dcCurrent>0.060 || $dcCurrent < 0.030 } { 
      SetMainStatus "Preamplifier power supply current is out of normal range."
      set errCount [expr $errCount + 1]
    }

    if { $errCount<1 } { SetMainStatus "Preamplifier power supply is ready." }
    return $errCount
}


proc checkPulseCounter {args} {
    set errCount 0

	# Check internal timer pulse
    set pulseCounter1 [getVar -var pulseCounter1 ]
    if {[expr abs($pulseCounter1 - 50000000)] > 10} { 
      SetMainStatus "Counter internal clock counts is incorrect: $pulseCounter1."
      set errCount [expr $errCount + 1]
    } 

	# Check revolution clock
    set pulseCounter3 [getVar -var pulseCounter3 ]
    if {[expr abs($pulseCounter3 - 271555)]>50} { 
      SetMainStatus "Revolution clock counts are out of range (normally 271555): $pulseCounter1"
      set errCount [expr $errCount + 1]
    }

	# Check APD detector pulse
    set pulseCounter4 [getVar -var pulseCounter4 ]
    if {$pulseCounter4>1000000} { 
      SetMainStatus "APD pulse rate is too high: $pulseCounter4"
      set errCount [expr $errCount + 1]
    }
    if {$pulseCounter4<1000} { 
      SetMainStatus "APD pulse rate is too low: $pulseCounter4"
      set errCount [expr $errCount + 1]
    }

    if { $errCount<1 } { SetMainStatus "Struck pulse counter is OK." }
    return $errCount
}


proc Instruction {args} {
    APSSetVarAndUpdate mainStatus "\n *** Instructions for starting Bunch Purity Monitor hardware ***"
    
    set device 0
    APSParseArguments {device}

	# Instruction for reboot FPGA unit	
    if {$device=="reboot"} { 
      APSSetVarAndUpdate mainStatus "Steps to reboot the FPGA unit located in 35BMA:"
      APSSetVarAndUpdate mainStatus "  1. Unplug the 24 V power plug on the front panel. Wait for 30 seconds."
      APSSetVarAndUpdate mainStatus "  2. Plug in the 24 V power plug."
      APSSetVarAndUpdate mainStatus "The FPGA unit will be ready in 2 - 5 minutes, depending on the network speed."
      return
    }

	# Instruction for starting DC power supply	
    if {$device=="apdpower"} { 
      APSSetVarAndUpdate mainStatus "Steps to start APD high-voltage power supply (Stanford Research Systems PS310) located in 35BMA:"
      APSSetVarAndUpdate mainStatus "  1. Turn off the power supply. (The push button is located on the lower right corner)"
      APSSetVarAndUpdate mainStatus "  2. Check the output connector at the back and cables to make sure they are securely connected."
      APSSetVarAndUpdate mainStatus "  3. Turn on the power supply. "
      APSSetVarAndUpdate mainStatus "  4. Push HIGH-VOLTAGE switch to ON button once (on the laft side)."
      APSSetVarAndUpdate mainStatus "The APD power supply is running. The current is ~ 0.02 mA through the drain resistor."
      return
    }

	# Instruction for starting APD power supply	
    if {$device=="dcpower"} { 
      APSSetVarAndUpdate mainStatus "Steps to start APD amplifier DC power supply (Agilent E3640A) located in 35BMC:"
      APSSetVarAndUpdate mainStatus "  1. Turn off the power supply. (Push button is located on the left of the unit)"
      APSSetVarAndUpdate mainStatus "  2. Check the output banana connector and cables to make sure they are securely connected."
      APSSetVarAndUpdate mainStatus "  3. Remove the 24 VDC plug on the FPGA control unit."
      APSSetVarAndUpdate mainStatus "  4. Turn on the power supply. The screen shows (RS-232) momentarily, then (0.00 V)"
      APSSetVarAndUpdate mainStatus "  5. Plug 24 VDC connector to the FPGA FPGA control unit. Wait for MEDM controls"
      APSSetVarAndUpdate mainStatus "  6. Enter 10 V into the box for Preamplifier Supply Volts. Hit RETURN."
      APSSetVarAndUpdate mainStatus "  7. Enter 12 V into the box for Preamplifier Supply Volts. Hit RETURN."
      APSSetVarAndUpdate mainStatus "The DC power supply is ready to run. The current is ~ 0.04 A."
      return
    }

    return
}


proc dcPower {args} {
    set action on
    APSParseArguments {action}

    if {$action=="on"} { 
      SetMainStatus "Turning on preamplifier DC power supply..."
      setVar -var dcPowerSwitch -value 1
      set dcVoltSet [getVar -var dcVoltSet]
      after 1000
      setVar -var dcVoltSet -value 1.0
      after 1000
      setVar -var dcVoltSet -value $dcVoltSet
    }
    if {$action=="off"} { 
      SetMainStatus "Turning off preamplifier DC power supply..."
      setVar -var dcPowerSwitch -value 0
    }
    
    after 2000
    checkDCPowerSupply

    return
}


proc apdPower {args} {
    set action on
    APSParseArguments {action}

    if {$action=="on"} { 
      SetMainStatus "Turning on APD power supply..."
      setVar -var apdPowerSwitch -value 1
      after 2000
      checkAPDPowerSupply -wait 20
    }
    if {$action=="off"} { 
      SetMainStatus "Turning off APD DC power supply..."
      setVar -var apdPowerSwitch -value 0
    }
        
    return
}


proc openShutters {args} {
    global abortRun
    global VERBOSE
 
    	# Open shutter
    SetMainStatus "Opening 35-BM photon shutter and safety shutter ..."
    setVar -var openPS2 -value 1
    
    	# Check shutter status
    checkShutters -wait 10
    
    return
}


proc pulseCounter {args} {

    # Set up old MCA timing
    # SetMainStatus "Set up MCA timing..."
    # setupMCATiming    
    
    SetMainStatus "Setting up Struck pulse counter..."
    setVar -var autoCountTime -value 1
    setVar -var countTime     -value 1
    setVar -var autoCount     -value 1
    setVar -var startCount    -value 1
    
    after 2000
    checkPulseCounter

    APSSetVarAndUpdate mainStatus "Set up MCA/ADC."
    exec /home/helios/PHOTODIA/operations/s35apps/Setup/s35BM_BPDmcaSetup

    return
}


proc setupFPGA {args} {
    global VERBOSE

    SetMainStatus "Setting up Bunch Purity FPGA unit."
    
    	# Reset Clock offset
    set clockOffset [getVar -var clockOffset]
    if { $clockOffset != 0 } {
      set newClockOffset [format %.0f [expr -1 * $clockOffset] ]
      SetMainStatus "Reset FPGA clock offset from $clockOffset to ZERO."
      setVar -var incrClockOffset -value $newClockOffset      
    }

    	# start clock scan
    SetMainStatus "Starting FPGA clock scan..."
    setVar -var clockScanStart -value 1
    setVar -var mca0AutoUpdate -value 2    
    for {set istep 1} {$istep <= 40} {incr istep} {
      after 5000
      set clockScanStatus [getVar -var clockScanStatus ]
      if { $clockScanStatus == "Idle" } { break }
      APSSetVarAndUpdate mainStatus "FPGA clock scan progress: $clockScanStatus"
      update
    }
    set clockScanResult [getVar -var clockScanResult ]
    SetMainStatus "FPGA clock scan results: $clockScanResult"
    
    # add additional offset to correct the bias (reason unknown).
    # setVar -var incrClockOffset -value -1
    # setVar -var incrClockOffset -value 1
    set clockOffset [getVar -var clockOffset]
    SetMainStatus "Final FPGA clock offset = $clockOffset."
    
    # Reset MCA0 long array (Menu-8 = 600 seconds)
    setVar -var mca0AutoUpdate -value 8
    setVar -var mca0Stop -value 1
    setVar -var mca0Clear -value 1
    setVar -var mca0Start -value 1
    setVar -var mca0Update -value 1
    
    # Data-logging and statistics uses array MCA 1. Its auto-update interval = 120 second = 2 minutes
    setVar -var mca1AutoUpdate -value 6

    # Bunch pattern data-logger: mca1Boxcar length = 5 (10 minutes per spectrum)
    setVar -var mca1BoxcarLen -value 5
    
    # Length of the bunch purity statistics boxcar averager: 30 sets x 120 sec/set = 60 minutes 
    setVar -var stBoxcarLen -value 30
    
    # Done setting up MCA 1, Restart it and all related accumulators
    setVar -var resetMCA1 -value 1
    
    # Set data logger control flag
    setVar -var loggingControl -value 1    
    
    SetMainStatus "setupFPGA: Done."
    return
}


proc setupMCATiming { } {

    APSSetVarAndUpdate mainStatus "Load bunch pattern."
    exec caput  S35BM:0BnchClkGenDisableBO 	0
    exec caput  S35BM:0BnchClkGenAutoLoadBO	0
    exec caput  S35BM:0BnchClkGenClearPatBO 	1
    exec caput  S35BM:0BnchClkGenLoadPatBO	1
    exec caput  S35BM:0BnchClkGenAutoLoadBO	1

    APSSetVarAndUpdate mainStatus "Set up MCA/ADC."
    exec /home/helios/PHOTODIA/operations/s35apps/Setup/s35BM_BPDmcaSetup

    APSSetVarAndUpdate mainStatus "Done."
    return
}


proc closeShutters {args} {
    global abortRun
    global VERBOSE
 
    set closeButton S35BM:PS2C:SS2C:Close:C
    exec caput $closeButton 1
    
    	# Watch shutter status
    for {set istep 1} {$istep <= 6} {incr istep} {
        after 1000
        set ps2Status [caget EPS:35:BM:PS2C:POSITION]
        if $VERBOSE {APSSetVarAndUpdate mainStatus "closeShutters: ps2Status = $ps2Status, abortRun = $abortRun"}
    	if {$ps2Status == "Closed"} {
           APSSetVarAndUpdate mainStatus "Shutters (PS2/SS) are closed."
    	   return 0
    	}
        if {$abortRun} {return 1}
    }

    APSSetVarAndUpdate mainStatus "Shutters (PS2/SS) are open."
    return
}


proc getPV {args} {
    global VERBOSE

    APSParseArguments {pv}

    if {[string length $pv] < 5} {
        if {$VERBOSE} {APSSetVarAndUpdate mainStatus "getPV: PV is not valid: $pv, return 0!"}
        set value 0
    } else {
        set value [caget $pv]
        if {$VERBOSE} {APSSetVarAndUpdate mainStatus "getPV: $pv has value of $value"}
        if [string match *Error* $value] {set value 0}
    }
    
    return $value
}


proc setPV {args} {
    global VERBOSE
    global authorizedUser
    global DRYRUN
    
    set readback 0
    set verbose 0
    APSParseArguments {pv value readback verbose}

    if {[string length $pv] < 5} {
        APSSetVarAndUpdate mainStatus "setPV: PV is not valid: $pv, No action taken!"
        return
    }
    
    if { ($DRYRUN!=0) || ($authorizedUser==0) } {
        APSSetVarAndUpdate mainStatus "pretend setting $pv to $value"
    } else {
        if {($VERBOSE!=0) || ($verbose!=0)} { APSSetVarAndUpdate mainStatus "Setting $pv to $value" }
        exec caput $pv $value
    }   

    if !$readback { return 0 }
    set newValue [getPV -pv $pv]
    return $newValue 
}


proc setVar {args} {
    global VERBOSE

    set var error
    set value 0
    set readback 0
    set verbose 0
    APSParseArguments {var value readback verbose}
    if {$VERBOSE} {APSSetVarAndUpdate mainStatus "setVar: (defaultVar) var=$var, verbose=$verbose"}
    if {$var == "error"} { return error }

    set pv [getPVName -var $var]
    if {$pv == 0} { return error }
    set newValue [setPV -pv $pv -value $value -readback $readback -verbose $verbose ]
    return $newValue
}


proc getVar {args} {
    global VERBOSE

    set var error
    APSParseArguments {var}
    if {$VERBOSE} {APSSetVarAndUpdate mainStatus "getVar: var=$var"}
    if {$var == "error"} { return error }

    set pv [getPVName -var $var]
    if {$var == 0} { return error }
    set value [getPV -pv $pv]
    return $value
}


proc getPVName {args} {
    global VERBOSE
    global frameGrabber
    
    APSStrictParseArguments {var}
    
    if {$VERBOSE} {APSSetVarAndUpdate mainStatus "var=$var"}
    switch $var {
        ps1Status       { set pv EPS:35:BM:PS1:POSITION }
        ps2Status       { set pv EPS:35:BM:PS2C:POSITION }
        openPS2         { set pv S35BM:PS2C:SS2C:Open:C }
        startCount      { set pv S35BM:3820:scaler1.CNT }
        countTime       { set pv S35BM:3820:scaler1.TP }
        autoCount       { set pv S35BM:3820:scaler1.CONT }
        autoCountTime   { set pv S35BM:3820:scaler1.TP1 }
        pulseCounter1   { set pv S35BM:3820:scaler1.S1 }
        pulseCounter2   { set pv S35BM:3820:scaler1.S2 }
        pulseCounter3   { set pv S35BM:3820:scaler1.S3 }
        pulseCounter4   { set pv S35BM:3820:scaler1.S4 }
        pulseCounter8   { set pv S35BM:3820:scaler1.S8 }
        apdPowerSwitch  { set pv SR:bpure2:HVPS:OffOn }
        apdPowerStatus  { set pv SR:bpure2:HVPS:Enabled }
        apdVoltSet      { set pv SR:bpure2:HVPS:Setpoint }
        apdVoltage      { set pv SR:bpure2:HVPS:Voltage }
        apdCurrent      { set pv SR:bpure2:HVPS:Current }
        dcPowerSwitch   { set pv SR:bpure2:PS:Enable }
        dcPowerStatus   { set pv SR:bpure2:PS:Enabled }
        dcVoltSet       { set pv SR:bpure2:PS:SetVoltage }
        dcVoltage       { set pv SR:bpure2:PS:Voltage }
        dcCurrent       { set pv SR:bpure2:PS:Current }

        comment1	{ # MCA 1 is for data logging }
        mca1AutoUpdate  { set pv SR:bpure2:st:AcqIntervalMBBO }
        stBoxcarLen     { set pv SR:bpure2:st:BoxcarLength }
        mca1BoxcarLen   { set pv SR:bpure2:st:BoxcarL }
        resetMCA1       { set pv SR:bpure2:st:MCAclearBoxcar }

        comment0	{ # MCA 0 is for debugging and maintanence }
        mca0AutoUpdate	{ set pv SR:bpure2:AcqIntervalMBBO }
        mca0Clear	{ set pv SR:bpure2:McaClearBO }
        mca0Start	{ set pv SR:bpure2:McaEnableBO }
        mca0Stop	{ set pv SR:bpure2:McaEnableBO }
        mca0Update	{ set pv SR:bpure2:MCAWF.PROC }
        clockScanStart  { set pv SR:bpure2:ClockScanStartBO }
        clockScanStatus { set pv SR:bpure2:ClockScanStateSI }
        clockScanResult { set pv SR:bpure2:ClockScanStatusSI }
        clockOffset     { set pv SR:bpure2:CounterMphaseAdjustmentLI }
        incrClockOffset { set pv SR:bpure2:CounterMphaseLO }
        loggingControl  { set pv SR:bpure2:LoggingControl }
    }
    
    return $pv
}


proc defaultVar {args} {
    global VERBOSE
    set var error
    APSParseArguments {var}

    set value ERROR
    if {$VERBOSE} {APSSetVarAndUpdate mainStatus "var = $var, value = $value"}
    switch $var {
        plotStop    { set value 3000 }
    }
    if {$VERBOSE} {APSSetVarAndUpdate mainStatus "var = $var, value = $value"}

    return $value
}


#########################################################
#	Define and initialize important global vars	#
#########################################################

proc initGlobalVars {args} {

    	# Program control
    global abortRun
    global PowerUser
    global VERBOSE
    global DRYRUN
    
    global noInit
    if ![info exists noInit] {
        set noInit   1
        set abortRun 0
        set VERBOSE  0
        set DRYRUN   0

    }

   return

}


#########################################################
#							#
#  	  MAIN PROGRAM: INTERACTIVE MODE		#
#							#
#########################################################

# Init global variables
initGlobalVars

# Process command line arguments
set PowerUser 0
set args $argv
APSParseArguments {PowerUser}

# Authorization setting: everyone can run it but sees different commands
set authorizedUser 1

if { [exec whoami]=="bxyang"} { 
   set authorTest 1
} else {
   set authorTest 0
}


#########################
#    INTERACTIVE MODE	#
#########################

# Menu bar
set CVSRevisionAuthor "\$Revision: 1.0 $ \$Author: b. yang $"

set appName "bpMonStartup-BM: FPGA Bunch Purity Monitor Setup"
APSApplication . -name $appName -version $CVSRevisionAuthor \
  -overview "Setup electronics for the S35 bunch purity detector"

set mainStatus "Start-up script for the bunch purity monitor \n"
APSScrolledStatus .status -parent .userFrame -width 100 -height 16 -textVariable mainStatus 

set mainStatus "When to run this script:"
set mainStatus "  1. After every beam dump / injection cycle."
set mainStatus "  2. After rebooting of iocs35idbl, iocs35idbl1, or the bunch purity FPGA unit."
set mainStatus "  3. After 35-BM bunch purity monitor hardware change / work.\n "

set mainStatus "How to run this script:"
set mainStatus "  1. Make sure that 35-BM hutches are searched and SHUTTER PERMIT is present."
set mainStatus "  2. Push the buttons in the first row in sequence: \[1\] --> \[2\] --> \[3\] --> \[4\]."
set mainStatus "     Wait for each command to complete before going on to the next command."
set mainStatus "  3. After running all commands, use \[Check Monitor\] to check bunch purity monitor status."
set mainStatus "     If total number of errors is not zero, repair the faulty component and run the script again."
# set mainStatus "     If the error persists after three attempts, contact Bingxin Yang (2-9821/2-1350/4-9821).\n"


######### WIDGETS ###########

SetupFrame    .setup   -parent .userFrame
CheckupFrame  .check   -parent .userFrame
HowToFrame    .howto   -parent .userFrame
if $authorTest { ShutdownFrame .shut    -parent .userFrame }
update


######### ADDITIONAL MENU ITEMS ###########

.menu.help.menu add command -label "HTML info file" -command {
    exec netscape "/home/helios/PHOTODIA/DeviceInfo/SR/Sector35/36AM/BunchPurity/BunchPurityMonitor.html" &
    # exit
}
.menu.help.menu insert 5 separator

.menu.help.menu add command -label "Toggle verbose mode" -command {
    set VERBOSE [expr 1 - $VERBOSE]
    APSSetVarAndUpdate mainStatus "set VERBOSE = $VERBOSE"
}
.menu.help.menu add command -label "Toggle DRYRUN mode" -command {
    set DRYRUN [expr 1 - $DRYRUN]
    APSSetVarAndUpdate mainStatus "set DRYRUN = $DRYRUN"
}
.menu.help.menu insert 7 separator





