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

# $Log: not supported by cvs2svn $
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)]
APSStandardSetup

set args $argv
set allowAllSectors 0
APSStrictParseArguments {allowAllSectors ignoreLock}
set CVSRevisionAuthor "\$Revision: 1.74 $ \$Author: shang $"

foreach type {ID BM CU} {
    set ${type}allowAllSectors $allowAllSectors
}

set sectorList ""
set IDSteering(sectorList) ""


set sectorList  [join [exec sdds2stream -col=Sector /home/helios/oagData/sr/IDs/sectors.sdds]]
foreach type {x xp y yp} {
    set ${type}SteerLimit [exec sdds2stream -col=${type}SteerLimit /home/helios/oagData/sr/IDs/sectors.sdds]
}
foreach sector $sectorList x $xSteerLimit y $ySteerLimit xp $xpSteerLimit yp $ypSteerLimit {
    set sectorf [format %02d $sector]
    set IDSteering(S$sectorf.xlimit) [format %.0f $x]
    set IDSteering(S$sectorf.ylimit) [format %.0f $y]
    set IDSteering(S$sectorf.xplimit) [format %.0f $xp]
    set IDSteering(S$sectorf.yplimit) [format %.0f $yp]
    set BMSteering(S$sectorf.yplimit) [format %.0f $yp]
    set CUSteering(S$sectorf.xlimit) [format %.0f $x]
    set CUSteering(S$sectorf.ylimit) [format %.0f $y]
    set CUSteering(S$sectorf.xplimit) [format %.0f $xp]
    set CUSteering(S$sectorf.yplimit) [format %.0f $yp]
}
set IDSteering(sectorList) $sectorList
set IDSteering(configDir) /home/helios/oagData/sr/knobs/IDbump/lattices/default

#BM Steering
set BMSteering(sectorList) [join [exec sdds2stream -col=Sector /home/helios/oagData/sr/BMs/sectors.sdds]]
set CUSteering(sectorList) [join [exec sdds2stream -col=Sector /home/helios/oagData/sr/BMs/sectors.sdds]]
set BMSteering(configDir) /home/helios/oagData/sr/knobs/BMbump/lattices/default


#CU Steeering
set CUSteering(sectorList) {2 6 11 12 13 15 16 21 22 23 24 25 28 31 32 34}
set CUSteering(sectorList) [join [exec sdds2stream -col=Sector /home/helios/oagData/sr/IDs/CUSteering.sdds]]
set CUSteering(configDir) /home/helios/oagData/sr/knobs/CUbump/lattices/default

set allSectors ""
for {set sector 1} {$sector<=40} {incr sector} {
	set sectorf [format %02d $sector]
    foreach steer {ID BM CU} {
	set ${steer}Steering(S$sectorf.configLoaded) 0
	set ${steer}Steering(S$sectorf.start) 0
	set ${steer}Steering(S$sectorf.checked) 0
	set ${steer}Steering(S$sectorf.limitStart) 0
	if [lsearch -exact $sectorList $sector]<0 {
	    set ${steer}Steering(S$sectorf.xlimit) 50
	    set ${steer}Steering(S$sectorf.ylimit) 50
	    set ${steer}Steering(S$sectorf.xplimit) 25
	    set ${steer}Steering(S$sectorf.yplimit) 25
	}
	set ${steer}Steering(S$sectorf.configFile) [set ${steer}Steering(configDir)]/${steer}$sectorf.cokn
    }
    lappend allSectors $sector
}


APSApplication . -name APSUSteeringServer \
  -overview "provides server controls for ID/BM/CU steering."

set tcl_precision 6

set IDSteeringStatus Ready.
APSScrolledStatus .status -parent .userFrame -width 50\
        -textVariable IDSteeringStatus 

proc SetIDSteeringStatus {text} {
    global IDSteeringStatus
    set IDSteeringStatus "[clock format [clock seconds] -format %H:%M:%S]: $text"
    update
}

proc MakeSteeringSectorsWidget {widget args} {
    global IDSteering CUSteering BMSteering  BMcheckbuttonList IDcheckbuttonList CUcheckbuttonList
    global IDallowAllSectors BMallowAllSectors CUallowAllSectors
    set parent ""
    set steerType ID
    APSParseArguments {parent steerType}
  
    set w $parent$widget
    APSFrame $widget -parent $parent \
      -label "Storage Ring $steerType selection for starting steering server." \
      -contextHelp {$steerType selection frame} 

    set buttonList ""
    set varList ""
    set commList ""
    for {set i 1} {$i<=40} {incr i} {
	set sectorf [format %02d $i]
	lappend buttonList $sectorf
	lappend varList ${steerType}Steering(S$sectorf.checked)
	lappend commList "MakeLimitWidget -sectorf $sectorf -steerType $steerType"
    }

    APSFrameGrid .grid -parent $w.frame -xList {x1 x2 x3 x4 x5}
    set w1 $w.frame.grid.x1
    set w2 $w.frame.grid.x2
    set w3 $w.frame.grid.x3
    set w4 $w.frame.grid.x4
    set w5 $w.frame.grid.x5
    set BMcheckbuttonList ""
    set j 0
    foreach sectorf $buttonList var $varList comm $commList {
	set sector [scan $sectorf %ld]
	set i [expr $sector%5]
	if {$i==0} {
	    set i 5
	}
	APSFrame .f$j -parent [set w$i] -label ""
	set f [set w$i].f$j.frame
	$f configure  -bd 0 -relief flat
	set button [APSCheckButtonFrame .c$sectorf -parent $f -label "" -buttonList $sectorf -packOption "-side left" -variableList $var ]
	APSButton .c1$sectorf -parent $f -text "limit" -size small -command $comm -packOption "-side left"
	lappend checkbuttonList $f.c$sectorf
	set ${steerType}Steering(S$sectorf.checkbutton) $button
	$button configure -bg grey90
	
	incr j
    }
    APSFrame .fa -parent $w.frame -label ""
    $w.frame.fa.frame configure -bd 0 -relief flat
    
    APSButton .all -parent $w.frame.fa.frame -text "All" -size small -command "SelectAll -value 1 -steerType $steerType"
    APSButton .none -parent $w.frame.fa.frame -text "None" -size small -command "SelectAll -value 0 -steerType $steerType"

    if ![set ${steerType}allowAllSectors] {
	for {set i 1} {$i<=40} {incr i} {
	    set button [lindex $checkbuttonList [expr $i-1]]
	    if [lsearch -exact [set ${steerType}Steering(sectorList)] $i]<0 {
		APSDisableWidget $button
	    }
	}
    }
    set ${steerType}checkbuttonList $checkbuttonList
    
    APSRadioButtonFrame .allow -parent $w.frame -label "Allow all sectors?" -buttonList {Yes No} \
	-valueList {1 0} -orientation horizontal -variable ${steerType}allowAllSectors \
	-commandList [list "EnableDisableSectors -steerType $steerType" "EnableDisableSectors -steerType $steerType"]
   
    #APSLabeledEntry .runtime -parent $w.frame -label "Server run time (0 means infinite) (seconds):" -width 15 \
#	-textVariable ${steerType}Steering(runTime)
    APSLabeledEntry .stepsize -parent $w.frame -label "Steering change limit (um/urad) per step:" -width 15 \
	-textVariable ${steerType}Steering(steeringStepSize) \
	-contextHelp "if it is smaller than the individual knob step size, it will overwrite that knob's step size"
    bind $w.frame.stepsize.entry <Return> "UpdateStepSize -steerType $steerType"
   
    APSLabeledEntry .pause -parent $w.frame -label "Wait time (seconds) between two steps:" -width 15 \
	-textVariable ${steerType}Steering(pauseTime) -contextHelp "if it is longer than the individaul knob wait time, it will overwrite that knob's wait time."
    bind $w.frame.pause.entry <Return> "UpdateStepSize -steerType $steerType"
    
    APSButton .check -parent $w.frame -text "Check Server" -command "CheckSteeringServer -steerType $steerType"
    global env
    
    APSButton .start1 -parent $w.frame -text "Start All" -command "StartSteeringServer -steerType $steerType -all 1"
    APSButton .abort1 -parent $w.frame -text "Abort All" -command "KillSteeringServer -steerType $steerType -all 1"
    APSButton .start -parent $w.frame -text "Start" -command "StartSteeringServer -steerType $steerType -all 0"
    APSButton .abort -parent $w.frame -text "Abort" -command "KillSteeringServer -steerType $steerType -all 0" \
	      -contextHelp "kill the $steerType steering knobs"
    APSButton .update -parent $w.frame -text "Update" -command "UpdateStepSize -steeringType $steerType"
    if ![regexp "ponos" $env(HOSTNAME)] {
	SetIDSteeringStatus "Can only start steering servers on ponos!"
	APSDisableButton $w.frame.start1.button
	APSDisableButton $w.frame.start.button
#	APSDisableButton $w.frame.abort1.button
#	APSDisableButton $w.frame.abort.button
    }
    APSButton .reset -parent $w.frame -text "ResetAll" -command "catch {exec cavput -list=S -range=begin=1,end=35,format=%02d -list=ID,BM -list=-Steering: -list=X,Xp,Y,Yp -list=_StatusM=0 -pend=3 -blunderAhead}"
}

proc EnableDisableSectors {args} {
    set steerType ID
    APSParseArguments {steerType}
    
    global ${steerType}checkbuttonList ${steerType}allowAllSectors ${steerType}Steering

    set checkbuttonList [set ${steerType}checkbuttonList]
    for {set i 1} {$i<=40} {incr i} {
	set button [lindex $checkbuttonList [expr $i-1]]
	if [lsearch -exact [set ${steerType}Steering(sectorList)] $i]<0 {
	    if ![set ${steerType}allowAllSectors] {
		set ${steerType}Steering(S[format %02d $i].checked) 0
		APSDisableWidget $button
	    } else {
		APSEnableWidget $button
	    }
	} else {
	    APSEnableWidget $button
	}
    }
}

set IDSteering(startedList) ""
set IDSTeering(startedPID) ""
set IDSteering(statusPV) ""
proc StartSteeringServer {args} {
    set steerType ID
    set all 0
    APSStrictParseArguments {steerType all}
    global ${steerType}Steering  BMcheckbuttonList IDcheckbuttonList CUcheckbuttonList

    set checkbuttonList [set ${steerType}checkbuttonList]
    set sectorList ""
    if !$all {
	for {set sector 1} {$sector<=40} {incr sector} {
	    set sectorf [format %02d $sector]
	    set button [lindex $checkbuttonList [expr $sector -1]]
	    if ![set ${steerType}Steering(S$sectorf.checked)] {
		continue
	    }
	    lappend sectorList $sector
	}
	if ![llength $sectorList] {
	    SetIDSteeringStatus "No sectors chosend for starting $steerType server."
	    return
	}
	set command "/home/oxygen/SHANG/oag/apps/src/tcltkapp/oagapp/startAbortSteeringSever -type $steerType -sectorList \"$sectorList\" -all 0 -abort 0"
	SetIDSteeringStatus "Starting $steerType steering server for sectors [join $sectorList ,]."
    } else {
	SetIDSteeringStatus "Starting $steerType steering server for all sectors."
	set command "/home/oxygen/SHANG/oag/apps/src/tcltkapp/oagapp/startAbortSteeringSever -type $steerType  -all 1 -abort 0"
    }
    global ${steerType}Started
    set ${steerType}Started 0
    APSExecLog .start$steerType -name "Start/Abort $steerType steering servers" -lineLimit 1024 \
	-unixCommand "$command" -callback "set ${steerType}Started 1" -abortCallback "set  ${steerType}Started aborted" \
	-cancelCallback "set ${steerType}Started cancelled."
   
    tkwait variable  ${steerType}Started
    after 5000
    CheckSteeringServer -steerType $steerType -sectorList "$sectorList"
    SetIDSteeringStatus "done."
}

proc CheckSteeringServer {args} {
    set steerType ID
    set sectorList ""
    APSParseArguments {steerType sectorList}
    global ${steerType}Steering  IDallowAllSectors BMallowAllSectors
    SetIDSteeringStatus "check $steerType steering status..."
    if ![llength $sectorList] {
	if [set ${steerType}allowAllSectors] {
	    for {set sector 1} {$sector<=40} {incr sector} {
		lappend sectorList $sector
	    }
	} else {
	    set sectorList [set ${steerType}Steering(sectorList)]
	}
    }
    foreach sector $sectorList {
	set sectorf [format %02d $sector]
	set started 0
	SetIDSteeringStatus "check S$sectorf..."
	foreach knobName [set ${steerType}Steering(S$sectorf.knobList)] runcontrol [set ${steerType}Steering(S$sectorf.runControlList)]  {
	    if [catch {exec cavget -list=$runcontrol.RUN -pend=10 } run] {
		return -code error "Error reading $runcontrol status: $run"
	    }
	    if !$run {
		set running 0
		#if [catch {exec pvinfo $knobName -w 15} result] {
		#    set running 0
		#	} else {
		#    set running 1
		#	}
	    }  else {
		set running 1
	    }
	    
	    if !$running {
		SetIDSteeringStatus "$knobName server not started."
	    } else {
		SetIDSteeringStatus "$knobName server started."
		incr started
	    }
	    exec cavput -list=[set ${steerType}Steering($knobName.startPV)]=$running
	}
	set ${steerType}Steering(S$sectorf.start) $started
	if {$started==[llength [set ${steerType}Steering(S$sectorf.knobList)]]} {
	    SetIDSteeringStatus "Sector $sector $steerType steering servers fully started."
	    [set ${steerType}Steering(S$sectorf.checkbutton)] configure -bg green1
	} elseif {$started==0} {
	    SetIDSteeringStatus "Sector $sector $steerType steering servers none started."
	    [set ${steerType}Steering(S$sectorf.checkbutton)] configure -bg grey90
	} else {
	    SetIDSteeringStatus "Sector $sector $steerType steering servers partially started."
	    [set ${steerType}Steering(S$sectorf.checkbutton)] configure -bg yellow
	}
    }
    SetIDSteeringStatus "done"
}

proc SelectAll {args} {
    set value 1
    set steerType ID
    APSParseArguments {value steerType}
    global IDSteering IDallowAllSectors BMallowAllSectors CUallowAllSectors BMSteering CUSteering
    for {set sector 1} {$sector<=40} {incr sector} {
	set sectorf [format %02d $sector]
	if ![set ${steerType}allowAllSectors] {
	    if [lsearch -exact [set ${steerType}Steering(sectorList)] $sector]<0 {
		#do nothing
	    } else {
		set ${steerType}Steering(S$sectorf.checked) $value
	    }
	} else {
	    set ${steerType}Steering(S$sectorf.checked) $value
	}
    }
}

proc KillSteeringServer {args} {
    set steerType ID
    set all 0
    APSParseArguments {steerType all}
    global ${steerType}Steering
   
    set sectorList ""
    if !$all {
	for {set sector 1} {$sector<=40} {incr sector} {
	    set sectorf [format %02d $sector]
	    if ![set ${steerType}Steering(S$sectorf.checked)] {
		continue
	    }
	    lappend sectorList $sector
	}
	set command "/home/oxygen/SHANG/oag/apps/src/tcltkapp/oagapp/startAbortSteeringSever -type $steerType -sectorList \"$sectorList\" -all 0 -abort 1"
	SetIDSteeringStatus "Abort $steerType steering server for sectors [join $sectorList ,]."
    } else {
	SetIDSteeringStatus "Abort $steerType steering server for all sectors."
	set command "/home/oxygen/SHANG/oag/apps/src/tcltkapp/oagapp/startAbortSteeringSever -type $steerType  -all 1 -abort 1"
    }
    global ${steerType}Aborted
    set ${steerType}Aborted 0
    APSExecLog .start$steerType -name "Start/Abort $steerType steering servers" -lineLimit 1024 \
	-unixCommand "$command" -callback "set ${steerType}Aborted 1" -abortCallback "set  ${steerType}Started aborted" \
	-cancelCallback "set  ${steerType}Started cancelled"
    tkwait variable  ${steerType}Aborted
    after 5000
    CheckSteeringServer -steerType $steerType -sectorList "$sectorList"
    
    SetIDSteeringStatus "done."
    return
}

set tmpRoot /tmp/[APSTmpString]
proc LoadConfig {args} {
    global IDSteering BMSteering CUSteering tmpRoot
    set sector ""
    set configDir ""
    set steerType ID
    APSParseArguments {sector configDir steerType}

    set sectorf [format %02d $sector]
    set file $configDir/${steerType}$sectorf.cokn
    if ![file exist $file] {
	return -code error "Config file ($file) does not exist for Sector $sector."
    }
    set pages [exec sdds2stream -npages=bar $file]
    set ${steerType}Steering(S$sectorf.knobList) ""
    for {set page 1} {$page<=$pages} {incr page} {
	if [catch {exec sddsconvert $file $tmpRoot.$steerType.S$sectorf.$page -from=$page -to=$page} result] {
	    return -code error "Error in sddsconvert: $result"
	}
	APSAddToTmpFileList -ID idstring -fileList $tmpRoot.$steerType.S$sectorf.$page
	set config $tmpRoot.$steerType.S$sectorf.$page 
	set knobName [exec sdds2stream $config -par=ControlName]
	set runControlPV [exec sdds2stream $config -par=RunControlPV]
	set ${steerType}Steering(S$sectorf.$knobName.configFile)  $config
	lappend ${steerType}Steering(S$sectorf.knobList) $knobName
	lappend ${steerType}Steering(S$sectorf.runControlList) $runControlPV
	
	APSAddToTmpFileList -ID idstree -fileList $tmpRoot.$steerType.S$sectorf.$page
	set statusPV [exec sdds2stream $config -par=SetStatusPV]
	set readbackPV [exec sdds2stream -par=SetRbvPV $config]
	set type [exec sdds2stream -par=KnobType $config]
	set limitPV [exec sdds2stream -par=SetValueLimitPV $config]
	set pausePV [exec sdds2stream -par=SetValueWaitTimePV $config]
	set stepSize [exec sdds2stream -par=DeltaLimit $config]
	set pause [exec sdds2stream -par=WaitTime $config]
	set ${steerType}Steering(${knobName}.limit)  [set ${steerType}Steering(S$sectorf.${type}limit)]
	set ${steerType}Steering(${knobName}.lowLimit) [expr -1.0 * [set ${steerType}Steering(S$sectorf.${type}limit)]]
	set ${steerType}Steering(${knobName}.highLimit) [set ${steerType}Steering(S$sectorf.${type}limit)]
	set ${steerType}Steering(${knobName}.readbackPV) $readbackPV
	set ${steerType}Steering(${knobName}.statusPV) $statusPV
	set ${steerType}Steering(${knobName}.status) ""
	set ${steerType}Steering(${knobName}.limitPV) $limitPV
	set ${steerType}Steering(${knobName}.stepSize) $stepSize
	set ${steerType}Steering(${knobName}.pausePV) $pausePV
	set ${steerType}Steering(${knobName}.pause) $pause
	set ${steerType}Steering(${knobName}.startPV) ${knobName}:ServerRunningM
    }
    
}

proc UpdateStepSize {args} {
    set steerType ID
    APSParseArguments {steerType}
    global ${steerType}Steering
    set varList ""
    set stepSize [set ${steerType}Steering(steeringStepSize)]
    set pause [set ${steerType}Steering(pauseTime)]
    set sectorList [set ${steerType}Steering(sectorList)]
    foreach sector $sectorList {
	set sectorf [format %02d $sector]
	if [set ${steerType}Steering(S$sectorf.checked)] {
	    SetIDSteeringStatus "updating step size for $steerType $sectorf..."
	    foreach knob [set ${steerType}Steering(S$sectorf.knobList)] {
		set stepPV [set ${steerType}Steering($knob.limitPV)]
		set pausePV [set  ${steerType}Steering($knob.pausePV)]
		if [catch {exec cavput -list=$stepPV=$stepSize,$pausePV=$pause -pend=10 } result] {
		    #return -code error "Error set the step limit and step pause: $result"
		}
	    }
	}
    }
    SetIDSteeringStatus "done."
}


proc MakeLimitWidget {args} {
    global IDSteering CUSteering BMSteering
    set sectorf ""
    set steerType ID
    APSParseArguments {sectorf steerType}
    
   
    set width 15
    
    set border 2
    set dialogFrame .dialog${steerType}$sectorf.userFrame
    if [winfo exist .dialog${steerType}$sectorf] {
	destroy .dialog${steerType}$sectorf
    }
    APSDialogBox .dialog${steerType}$sectorf  \
	-name "${steerType}$sectorf limit Dialog" \
	-contextHelp "Dialog box for steering limit of ${steerType}$sectorf." 
    
    
    APSFrame .parameters -parent $dialogFrame 
    $dialogFrame.parameters.frame configure -relief flat
    set w $dialogFrame.parameters.frame
    
    set pvList ""
    set varList ""
    APSLabel .label -parent $w -text "                                         Low Limit       High Limit    Steered Value"
    foreach knob [set ${steerType}Steering(S$sectorf.knobList)] {
	if [regexp {Xp} $knob] {
	    set type xp
	    set unit urad
	} elseif [regexp {Yp} $knob] {
	    set type yp
	    set unit urad
	} elseif [regexp {X} $knob] {
	    set type x
	    set unit um
	} else {
	    set type y
	    set unit um
	}
	
	APSLabeledEntryFrame .a$type -parent $w -label "${steerType}$sectorf $type ($knob) ($unit):" \
	    -width $width -variableList [list ${steerType}Steering($knob.lowLimit) ${steerType}Steering($knob.highLimit) ${steerType}Steering($knob.readbackValue)] -orientation horizontal
	lappend varList ${steerType}Steering($knob.lowLimit) 
	lappend varList ${steerType}Steering($knob.highLimit)
	lappend varList ${steerType}Steering($knob.readbackValue)
	
	lappend pvList [set ${steerType}Steering($knob.readbackPV)].DRVL
	lappend pvList [set ${steerType}Steering($knob.readbackPV)].DRVH
	lappend pvList [set ${steerType}Steering($knob.readbackPV)]
	bind $w.a$type.frame.entry1 <Return> "UpdateLimit -sectorf $sectorf -steerType $steerType"
	bind $w.a$type.frame.entry2 <Return> "UpdateLimit -sectorf $sectorf -steerType $steerType"
	APSButton .zero$type -parent $w.a$type -packOption "-side right"  -text "reset" -size small -command "ResetSteering -knob $knob -steerType $steerType" \
	    -contextHelp "reset the steering readback value to zero."
    }
    if {![set ${steerType}Steering(S$sectorf.limitStart)]} {
	pv linkw $varList $pvList
	pv putw $varList
	pv getw $varList
	
	foreach var $varList {
	    pv umon $var
	}
    }
    set ${steerType}Steering(S$sectorf.limitStart) 1
}

proc ResetSteering {args} {
    global IDSteering CUSteering BMSteering
    set knob ""
    set steerType ID
    APSParseArguments {knob steerType}
    set ${steerType}Steering($knob.readbackValue) 0
    pv putw ${steerType}Steering($knob.readbackValue)
    exec caput  [set ${steerType}Steering($knob.statusPV)] 0
    
}

proc UpdateLimit {args} {
    global IDSteering
    set sectorf ""
    set steerType  ID
    APSParseArguments {sectorf steerType}
    if ![set ${steerType}Steering(S$sectorf.start)] {
	return -code error "Sector $sectorf $steerType steering server have not started yet, can not change its steering limit!"
    }
    foreach knob [set ${steerType}Steering(S$sectorf.knobList)] {
	pv putw ${steerType}Steering($knob.lowLimit)
	pv putw ${steerType}Steering($knob.highLimit)
    }
}

set IDSteering(runTime) 0
set IDSteering(steeringStepSize) 2
set IDSteering(bpmStepSize) 2
set IDSteering(pauseTime) 2
set BMSteering(runTime) 0
set BMSteering(steeringStepSize) 2
set BMSteering(bpmStepSize) 2
set BMSteering(pauseTime) 2
set CUSteering(runTime) 0
set CUSteering(steeringStepSize) 2
set CUSteering(bpmStepSize) 2
set CUSteering(pauseTime) 2

set wList [APSTabFrame .tab -parent .userFrame -labelList {IDSteering CUSteering BMSteering} -height 450 -width 600]
set w1 [lindex $wList 0]
set w2 [lindex $wList 1]
set w3 [lindex $wList 2]
MakeSteeringSectorsWidget .sectors -parent $w1 -steerType ID
MakeSteeringSectorsWidget .sectors -parent $w2 -steerType CU
MakeSteeringSectorsWidget .sectors -parent $w3 -steerType BM

for {set sector 1} {$sector<=40} {incr sector} {
    SetIDSteeringStatus "Loading sector $sector ID config..."
    LoadConfig -sector $sector -configDir $IDSteering(configDir) -steerType ID
    SetIDSteeringStatus "Loading sector $sector BM config..."
    LoadConfig -sector $sector -configDir $BMSteering(configDir) -steerType BM
}

SetIDSteeringStatus "checking ID steering server..."
CheckSteeringServer -steerType ID
SetIDSteeringStatus "checking BM steering server..."
CheckSteeringServer -steerType BM
#UpdateStepSize -steerType ID
#UpdateStepSize -steerType BM
SetIDSteeringStatus "done."
SetIDSteeringStatus "To start/abort steering servers, you need login to ponos and start this GUI!"

#monitor runcontrol
