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

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 sector 1
set odd 1
set even 0
set args $argv
set dir .
set rootname ""
APSParseArguments {sector odd even dir rootname}

set sector [scan $sector %d]
set LMPS(sector) $sector
set LMPS(sector1) [expr $sector+1]
set LMPS(odd) $odd
set LMPS(even) $even

set sectorf [format %02d $sector]
set LMPS(linkFaultPV) APSU:MMPS1:LMPS[expr ($sector+1)/2]:Fault-I
puts "link: $LMPS(linkFaultPV)"
set LMPS(localMPSPV) S${sectorf}-LMPS:MLinkTXpkt_FS-I
puts "lmps: $LMPS(localMPSPV)"
set fsector [expr ($sector+1)/2-1] 
set Bit [format %X $fsector]
set LMPS(main1fastPV) APSU:MMPS1:LMPS:FastAbort-Sts.B$Bit
set LMPS(main1slowPV) APSU:MMPS1:LMPS:SlowAbort-Sts.B$Bit
set LMPS(main2fastPV) APSU:MMPS2:SMA:Data10-I.B$Bit
set LMPS(main2slowPV) APSU:MMPS2:SMA:Data11-I.B$Bit


set LMPS(odd.extInputPV) S[format %02d $sector]-LMPS:CtrlReg0-Cmd.B12
set LMPS(even.extInputPV) S[format %02d $sector]-LMPS:CtrlReg0-Cmd.B11
set LMPS(odd.testPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.BA
set LMPS(even.testPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B6
#bankB for channel 17-20 (acutally should go to channel 31)
set LMPS(bankBPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B1 
#bankA  #for channel 9-16
set LMPS(bankAPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B2
#when both bankAPV and bankBPV are selected, for channel 1-8
set LMPS(BIT0PV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B5
set LMPS(BIT1PV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B4
set LMPS(BIT2PV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B3

set LMPS(odd.extInputChanPV)  S[format %02d $sector]-LMPS:ExtInMData0-I
set LMPS(odd.extFaultChanPV)  S[format %02d $sector]-LMPS:ExtInFaultData0-I
set LMPS(even.extInputChanPV)  S[format %02d $sector]-LMPS:ExtInMData1-I
set LMPS(even.extFaultChanPV)  S[format %02d $sector]-LMPS:ExtInFaultData1-I

set LMPS(localMPSFaultPV) S[format %02d $sector]-LMPS:MLinkTXpkt_FS-I
set LMPS(currentTimeFlagPV) S[format %02d $sector]-LMPS:EVR_TS-SI
#odd fast abort mask: 0x35  slow abort mask: 0xFFF0A;
set LMPS(odd.fastAbortMaskPV) S[format %02d $sector]-LMPS:ExtInFastMask0-SP
set LMPS(odd.slowAbortMaskPV) S[format %02d $sector]-LMPS:ExtInSlowMask0-SP

#even fast abort mask: 0xFF  slow abort mask: 0xFF
set LMPS(even.fastAbortMaskPV) S[format %02d $sector]-LMPS:ExtInFastMask1-SP
set LMPS(even.slowAbortMaskPV) S[format %02d $sector]-LMPS:ExtInSlowMask1-SP

if [catch {exec cavget -list=$LMPS(odd.fastAbortMaskPV),$LMPS(odd.slowAbortMaskPV),$LMPS(even.fastAbortMaskPV),$LMPS(even.slowAbortMaskPV) -pend=10 -printError} valList] {
    puts stderr "Error reading fast and slow abort mask: $valList"
    exit 1
}
set oddFastMask [lindex $valList 0]
set oddSlowMask [lindex $valList 1]
set evenFastMask [lindex $valList 2]
set evenSlowMask [lindex $valList 3]

if $odd {
    set configFile /home/oxygen/SHANG/MPS/LMPSconfig_odd.sdds
} else {
    set configFile /home/oxygen/SHANG/MPS/LMPSconfig_even.sdds
}
set channelList [exec sdds2stream -col=InputChannel $configFile]
set descList [exec sdds2stream -col=InputFaultName $configFile]
set faultList [exec sdds2stream -col=AbortType $configFile]
set LMPS(faultTypes) [exec sdds2stream -rows=bar $configFile]
set fastMaskBits [exec sdds2stream -col=FastAbortMaskBit $configFile]
set slowMaskBits [exec sdds2stream -col=SlowAbortMaskBit $configFile]
set fastMask 0
set slowMask 0
for {set i 0} {$i<$LMPS(faultTypes)} {incr i} {
    if [lindex $fastMaskBits $i] {
	set fastMask [expr $fastMask + pow(2,$i)]
    }
    if [lindex $slowMaskBits $i] {
	set slowMask [expr $slowMask+pow(2,$i)]
    }
}
set LMPS(fastMask) [format %.0f $fastMask]
set LMPS(slowMask) [format %.0f $slowMask]
set LMPS(dir) $dir

for {set chan 1} {$chan<=20} {incr chan} {
    set index [lsearch -exact $channelList $chan]
    if $index<0 {
	set desc Not_Used
	set fault Not_Used
    }  else {
	set desc [lindex $descList $index]
	set fault [lindex $faultList $index]
    }
    set LMPS(chan$chan.fault) $fault
    set LMPS(chan$chan.input) $desc
    if [regexp "Fast" $fault] {
	set LMPS(chan$chan.fast) 1
	set LMPS(chan$chan.slow) 0
	set LMPS(chan$chan.linkFault) 1
	set LMPS(chan$chan.mpsFault) 1
	set LMPS(chan$chan.hasfault) 1
    } elseif [regexp "Slow" $fault] {
	set LMPS(chan$chan.fast) 0
	set LMPS(chan$chan.slow) 1
	set LMPS(chan$chan.linkFault) 8
	set LMPS(chan$chan.mpsFault) 8
	set LMPS(chan$chan.hasfault) 1
    } elseif [regexp "Gap" $fault] {
	set LMPS(chan$chan.fast) 0
	set LMPS(chan$chan.slow) 0
	set LMPS(chan$chan.linkFault) 0
	set LMPS(chan$chan.mpsFault) 0
	set LMPS(chan$chan.hasfault) 0
    } else {
	set LMPS(chan$chan.fast) 0
	set LMPS(chan$chan.slow) 0
	#can be slow (8) or fast (1) [expr 1 | 8]
	set LMPS(chan$chan.linkFault)  9
	set LMPS(chan$chan.mpsFault) 9
	set LMPS(chan$chan.hasfault) 1
    }
    set LMPS(odd.chan$chan.timeFlagPV) S[format %02d $sector]-LMPS:ExtIn[expr $chan - 1]_TS-SI
    set LMPS(even.chan$chan.timeFlagPV) S[format %02d $sector]-LMPS:ExtIn[expr $chan + 19]_TS-SI
}

#local sector fast fault = [expr ($sector+1)/2]
set fsector [expr ($sector+1)/2]
#main2 fast and slow has 21 bits when there is fault
set LMPS(findex) [expr 21 - $fsector]
#main1 and main2 fast and slow faults findex must be 1
puts "findex $LMPS(findex)"

#channel selection
#BankA=0 and BankB=0           BankA             BANKB
#BIT0 BIT1 BIT2 channel        channel           channel
#0    0    0    1              9                 17
#1    0    0    2              10                18
#0    1    0    3              11                19
#1    1    0    4              12                20
#0    0    1    5              13
#1    0    1    6              14
#0    1    1    7              15
#1    1    1    8              16


set LMPS(odd.sectorSelectPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B0
set LMPS(odd.topBankSelectPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B7
set LMPS(even.topBankSelectPV) S[format %02d $sector]-LMPS:GPIO:OUT-Cmd.B8

set LMPS(resetPV) S[format %02d $sector]-LMPS:UsrReset-SP
set LMPS(armStatusPV) S[format %02d $sector]-LMPS:SysStatus-I.BC

set names [array names LMPS]
set pvList ""
set varList ""
foreach name $names {
    set lastname [string range $name end-1 end]
    if {$lastname=="PV"} {
	lappend pvList $LMPS($name)
	lappend varList LMPS($name.var)
	#set LMPS($name.var) 0
    }
}

pv linkw $varList $pvList 30
#ext input fast mask 1048575
#ext input slow mask 0
set LMPS(fastMaskPV.var) 1048575
set LMPS(slowMaskPV.var) 0

proc ClearAll {args} {
    global pvList LMPS odd even sectorf
    
    #set all masks to zero before clear
    exec cavput -list=S$sectorf -list=-LMPS:ExtIn -list=SimData,Mask -list=0,1 -list=-SP=0 -pend=10
    
    after 1000
    
    foreach pv $pvList {
	if {[regexp "LMPS:TSReset-SP" $pv]} {
	    lappend putList $pv=1
	   # continue
	}
	#lappend putList $pv=0
    }
  #  puts $putList
  #  puts "$putList"
   #if [catch {APScavput -list=[join $putList ,] -pend=10} result] {#
#	return -code error "Error clear all: $result"
    #  }
    #clear GPIO bits
    exec caput $LMPS(odd.extInputPV) 0
    exec caput $LMPS(even.extInputPV) 0
    exec cavput -list=S${sectorf}-LMPS:GPIO:OUT-Cmd.B -list=0=0,1=0,2=0,3=0,4=0,5=0,6=0,7=0,8=0,A=0

   # exec caput LMPS:TSReset-SP 1

    
    puts $LMPS(resetPV)
    exec caput $LMPS(resetPV) 1
    #set all masks to FFFF after clear
    
    exec cavput -list=S$sectorf -list=-LMPS:ExtIn -list=SimData,Mask -list=0,1 -list=-SP=1048575 -pend=10
}

proc InitTest {args} {
    set odd 1
    APSParseArguments {odd}
    global LMPS
    #if [catch {APScavput -list=APSU:MMPS2:CtrlReg0-Cmd.B2=0 -pend=10} result] {
  #	return -code error "Error disarming system: $result"
  #   }
    if $odd {
	puts "Setup test for odd channels..."
	#enable odd extInput and test PV, disable even extInput and test PV
	puts $LMPS(odd.extInputPV) 
	exec caput $LMPS(odd.extInputPV) 1
	exec caput $LMPS(odd.testPV) 1
	exec caput $LMPS(even.extInputPV) 0
	exec caput $LMPS(even.testPV) 0
	#enable odd sector selection
	exec caput $LMPS(odd.sectorSelectPV) 1
	#enable odd top bank select pv, disable even top bank select pv
	exec caput $LMPS(odd.topBankSelectPV) 1
	exec caput $LMPS(even.topBankSelectPV) 0
	#value 0xFFF0A = 1048330 value 0x35 = 53
	exec caput $LMPS(odd.fastAbortMaskPV) $LMPS(fastMask)
	exec caput $LMPS(odd.slowAbortMaskPV) $LMPS(slowMask)
	
    } else {
	puts "Setup test for even channels..."
	#enable even extInput and test PV, disable odd extInput and test PV
	exec caput $LMPS(odd.extInputPV) 0
	exec caput $LMPS(odd.testPV) 0
	exec caput $LMPS(even.extInputPV) 1
	exec caput $LMPS(even.testPV) 1

	
	#disable odd sector selection
	exec caput $LMPS(odd.sectorSelectPV) 0

	#enable even topbank select pv disable odd top bank select pv
	exec caput $LMPS(odd.topBankSelectPV) 0
	exec caput $LMPS(even.topBankSelectPV) 1
	#value 0xFFF0A = 1048330
	exec caput $LMPS(even.fastAbortMaskPV) $LMPS(fastMask)
	#value 0x35 = 53
	exec caput $LMPS(even.slowAbortMaskPV) $LMPS(slowMask)
    }
    #disable bank selection
    exec caput $LMPS(bankBPV) 0
    exec caput $LMPS(bankAPV) 0
    exec caput $LMPS(BIT0PV) 0
    exec caput $LMPS(BIT1PV) 0
    exec caput $LMPS(BIT2PV) 0
    exec caput $LMPS(resetPV) 1
    #reset timestamps
    exec caput S[format %02d $LMPS(sector)]-LMPS:TSReset-SP 1
    exec caput S[format %02d $LMPS(sector)]-LMPS:PM:Reset-SP 1
}

proc RESET {args} {
    global LMPS
    set odd 1
    APSParseArguments {odd}
    puts "RESET ..."
    if $odd {
	set LMPS(odd.topBankSelectPV.var) 1
	pv putw LMPS(odd.topBankSelectPV.var)
	#	exec caput $LMPS(odd.topBankSelectPV) 1
	#exec caput $LMPS(even.topBankSelectPV) 0
    } else {
	#exec caput $LMPS(odd.topBankSelectPV) 0
	#exec caput $LMPS(even.topBankSelectPV) 1
	set LMPS(even.topBankSelectPV.var) 1
	pv putw LMPS(even.topBankSelectPV.var)
    }
    #exec caput $LMPS(reset) 1
    set LMPS(resetPV.var) 1
    pv putw LMPS(resetPV.var)
    after 5000
    
}


proc SelectChannel {args} {
    set channel 1
    set odd 1
    APSParseArguments {channel odd}
    global pvList varList
#channel selection
#BankA=0 and BankB=0           BankA             BANKB
#BIT0 BIT1 BIT2 channel        channel           channel
#0    0    0    1              9                 17
#1    0    0    2              10                18
#0    1    0    3              11                19
#1    1    0    4              12                20
#0    0    1    5              13
#1    0    1    6              14
#0    1    1    7              15
#1    1    1    8              16
    
    global LMPS
    set bankA 0
    set bankB 0
    if $channel<9 {
	set chan $channel
    } elseif {$channel<17} {
	set bankA 1
	set chan [expr $channel - 8]
    } else {
	set bankB 1
	set chan [expr $channel - 16]
    }
    pv getw $varList
    set bankA0 $LMPS(bankAPV.var)
    set bankB0 $LMPS(bankBPV.var)
    if {$bankA0!=$bankA} {
	set LMPS(bankAPV.var) $bankA
	pv putw LMPS(bankAPV.var)
    }
    if {$bankB0!=$bankB} {
	set LMPS(bankBPV.var) $bankB
	pv putw LMPS(bankBPV.var)
    }
    
    set chan [expr $chan -1]
    set bitstr [format %03b $chan]
  
    set LMPS(BIT0PV.var) [string index $bitstr 2]
    set LMPS(BIT1PV.var) [string index $bitstr 1]
    set LMPS(BIT2PV.var) [string index $bitstr 0]
    pv putw LMPS(BIT0PV.var) 
    pv putw LMPS(BIT1PV.var) 
    pv putw LMPS(BIT2PV.var)
    if $odd {
	set LMPS(odd.topBankSelectPV.var) 0
	pv putw LMPS(odd.topBankSelectPV.var)
	#	exec caput $LMPS(odd.topBankSelectPV) 0
    } else {
	set LMPS(even.topBankSelectPV.var) 0
	pv putw LMPS(even.topBankSelectPV.var)
	#exec caput $LMPS(even.topBankSelectPV) 0
    }
    after 2000
}


proc TestSector {args} {
    set odd 1
    set sector 1
    APSParseArguments {odd sector}

    global LMPS varList pvList
    pv getw $varList
    update
    if $odd {
	set sector1 $sector
	set sect "odd"
	set Sect "Odd"
    } else {
	set sector1 [expr $sector+1]
	set sect "even"
	set Sect "Even"
    }
   
    #pv getw LMPS(currentTimeFlagPV.var)
    set time0 [clock scan [join [split $LMPS(currentTimeFlagPV.var) ","]]]
    set LMPS(startTime) $time0

    set LMPS($sector1.passed) 1
    WriteReportHeader -sector $sector -odd $odd
    for {set channel 1} {$channel<=20} {incr channel} {
	set LMPS($sector1.chan$channel.passed) 1
	##puts "set fast and slow abort mask..."
	#SetMasks -channel $channel
	#after 1000
	puts "\tTesting $sect input channel $channel, fault type=$LMPS(chan$channel.fault)..."
	flush stdout
	if [catch {SelectChannel -odd $odd -channel $channel} result] {
	    puts stderr "Error selecting $sect channel $channel: $rsult"
	    exit 1
	}
	after 4000
	pv getw $varList
	
	set inputChan $LMPS($sect.extInputChanPV.var)
	set faultChan $LMPS($sect.extFaultChanPV.var)
	set inputChan [expr 1048575 - $inputChan]
	set LMPS($sector1.chan$channel.input) [format 0x%x $inputChan]
	set LMPS($sector1.chan$channel.fault) [format 0x%x $faultChan]
	set time [clock scan [lindex [split $LMPS($sect.chan$channel.timeFlagPV.var) "."] 0]]
	puts "\t$Sect Sector Inputs : [format 0x%x $inputChan]"
	puts "\t$Sect Sector Faults : [format 0x%x $faultChan]"
	puts "\t------------------------------------------------"
	flush stdout
	set desc ""
	#check if input channel and fault channel agree
	if {$inputChan!=$faultChan} {
	    set LMPS($sector1.chan$channel.passed) 0
	    append desc "input channel!=fault channel. "
	}
	#check the fault time stamp if within 3 minutes
	set desc ""
	set LMPS($sector1.chan$channel.faultTime) passed
	if [expr abs($time-$time0)]>300 {
	    set LMPS($sector1.chan$channel.passed) 0
	    append desc "fault time out of range. "
	    set LMPS($sector1.chan$channel.faultTime) failed
	}
	#check if the fault status agree
	set LMPS($sector1.chan$channel.MPS) passed
	set mpspassed [CheckMPSFault -sector1 $sector1 -channel $channel]
	if !$mpspassed {
	    set LMPS($sector1.chan$channel.MPS) failed
	    set LMPS($sector1.chan$channel.passed) 0
	    #append desc "local MPS fault status does not agree."
	    append desc $LMPS(chan$channel.mpsDesc)
	}
	
	if !$LMPS($sector1.chan$channel.passed) {
	    set LMPS($sector1.passed) 0
	    puts "\t$Sect sector channel $channel test failed: $desc"
	    set LMPS($sector1.chan$channel.result) failed
	} else {
	    puts "\t$Sect sector channel $channel test passed."
	    set LMPS($sector1.chan$channel.result) passed
	}
	set LMPS(chan$channel.faultDesc) $desc
	flush stdout
	after 1000
	RESET -odd $odd
    }
    WriteTestFile -sector $sector -odd $odd
}

proc SetMasks {args} {
    set channel ""
    APSParseArguments {channel}
    global LMPS
    set sectorf [format %02d $LMPS(sector)]
    if [regexp "Gap" $LMPS(chan$channel.fault)] {
	set fast 0
    } else {
	set fast 1048575
    }
    if [catch {APScavput -list=S${sectorf}-LMPS:ExtInFastMask1-SP=$fast,S${sectorf}-LMPS:ExtInFastMask0-SP=$fast,S${sectorf}-LMPS:ExtInSlowMask1-SP=0,S${sectorf}-LMPS:ExtInSlowMask0-SP=0 -pend=10 } result] {
	return -code error "Error setting masks: $result"
    }
}
proc CheckMPSFault {args} {
    set channel 1
    set sector1 1
    APSParseArguments {channel sector1}
    global LMPS varList
    pv getw $varList
    update
    
    
    set desc ""
    set passed 1
    
    if {$LMPS(linkFaultPV.var) == $LMPS(chan$channel.linkFault)} {
	puts "\tSector $sector1 link fault status: agree"
    } else {
	puts "\tSector $sector1 link fault status: do not agree"
    }
    if {$LMPS(localMPSPV.var) == $LMPS(chan$channel.mpsFault)} {
	puts "\tSector $sector1 local MPS fault status: agree"
    } else {
	puts "\tSector $sector1 local MPS fault status: do not agree"
    }
    set main1fast $LMPS(main1fastPV.var)
    set main1slow $LMPS(main1slowPV.var)
    set main2fast $LMPS(main2fastPV.var)
    set main2slow $LMPS(main2slowPV.var)
    set fast1 $main1fast
    set slow1 $main1slow
    set fast2 $main2fast
    set slow2 $main2slow
    foreach nm {1 2} {
	foreach type {fast slow} {
	    set var ${type}$nm
	    if {[set $var]} {
		puts "\tSector $sector1 main$nm $type fault: Yes"
	    } else {
		puts "\tSector $sector1 main$nm $type fault: No"
	    }
	}
    }
    
    
    if !$LMPS(chan$channel.hasfault) {
	if {$LMPS(linkFaultPV.var) || $LMPS(localMPSPV.var)} {
	    set passed 0
	    append desc "link/localMPS has fault."
	}
	#main1 and main2 should have no fault for this sector
	if {([string length $fast1] && $fast1==1) || \
		([string length $slow1] && $slow1==1) || \
		([string length $fast2] && $fast2==1) || \
		([string length $slow2] && $slow2==1) } {
	    set passed 0
	    append desc "main1/main2 has fault."
	}
    } else {
	#check local link error
	if {$LMPS(linkFaultPV.var) != $LMPS(chan$channel.linkFault)} {
	    set passed 0
	    append desc "link fault failed."
	} 
	#check local MPS fault 
	if {$LMPS(localMPSPV.var) != $LMPS(chan$channel.mpsFault)} {
	    set passed 0
	    append desc "local mps failed."
	}
	# main1/main2 fast/slow abort
	if {$LMPS(chan$channel.fast)} {
	    if {$fast1!=1} {
		set passed 0
		append desc "main1 fast abort failed."
	    }
	    if {$fast2!=1} {
		set passed 0
		append desc "main2 fast abort failed."
	    }
	}
	if {$LMPS(chan$channel.slow)} {
	    if {$slow1!=1} {
		set passed 0
		append desc "main1 slow abort failed."
	    }
	    if {$slow2!=1} {
		set passed 0
		append desc "main2 slow abort failed."
	    }
	}
    }
    set LMPS(chan$channel.mpsDesc) $desc
    switch $LMPS(localMPSFaultPV.var) {
	1 {
	    set LMPS(chan$channel.MPSFault) Fast_Abort
	}
	8 {
	    set LMPS(chan$channel.MPSFault) Slow_Abort
	}
	0 {
	    set LMPS(chan$channel.MPSFault) No_Fault
	}
	default {
	    set LMPS(chan$channel.MPSFault) Unknown
	}
    }
    return $passed
    
    pv getw LMPS(localMPSFaultPV.var)
    switch $LMPS(chan$channel.fault) {
	Fast_Abort {
	    set value 1
	} 
	Slow_Abort {
	    set value 8
	}
	default {
	    set value 0
	}
    }
    
    if $channel>$LMPS(faultTypes) {
	return 1
    }
    if {$LMPS(localMPSFaultPV.var)!=$value} {
	return 0
    } else {
	return 1
    }
}

proc WriteReportHeader {args} {
    set sector 1
    set odd 1
    APSParseArguments {sector odd}
    global LMPS
    
    if $odd {
	set sector1 $sector
	set rootname $LMPS(odd.rootname)
#	set LMPS(odd.textFID) [open $rootname.txt "w"]
	set LMPS(odd.sddsFID) [open $rootname.sdds "w"]
#	set txtFID $LMPS(odd.textFID)
	set sddsFID $LMPS(odd.sddsFID)
	set Sect "Odd"
	set sect odd
    } else {
	set sector1 [expr $sector + 1]
	set rootname $LMPS(even.rootname)
#	set LMPS(even.textFID) [open $rootname.txt "w"]
	set LMPS(even.sddsFID) [open $rootname.sdds "w"]
#	set txtFID $LMPS(even.textFID)
	set sddsFID $LMPS(even.sddsFID)
	set Sect "Even"
	set sect even
    }
    #text file header
    if {0} {
	puts $txtFID "Test Date: [lindex [split $LMPS(currentTimeFlagPV.var) ","] 0]"
	puts $txtFID "----------------------------------------------"
	puts $txtFID "Local MPS Test Report for APSU $sector1 sector"
	puts $txtFID "----------------------------------------------"
	puts $txtFID "Sector\#    Test Channel   Fault_Time_ok      Input Value     Fault Value       MPS_Fault         Result       Input_Fault"
	puts $txtFID "----------------------------------------------------------------------------------------------------------------------------"
    }
    
    #sdds header
    puts $sddsFID "SDDS1"
    puts $sddsFID "&parameter name=TestDate type=string &end"
    puts $sddsFID "&parameter name=Description type=string &end"
    puts $sddsFID "&parameter name=DoubleSector type=long &end"
    puts $sddsFID "&parameter name=StartTime type=double &end"
    puts $sddsFID "&parameter name=TestPassed type=string &end"
    puts $sddsFID "&column name=Sector type=long &end"
    puts $sddsFID "&column name=InputChannel type=long &end"
    puts $sddsFID "&column name=InputName type=string &end"
    puts $sddsFID "&column name=AbortType type=string &end"
    puts $sddsFID "&column name=TimeStamp type=string &end"
    puts $sddsFID "&column name=FaultTimeOK type=string &end"
    puts $sddsFID "&column name=InputValue type=string &end"
    puts $sddsFID "&column name=FaultValue type=string &end"
    puts $sddsFID "&column name=Result type=string &end"
    puts $sddsFID "&column name=FaultDesc type=string &end"
    puts $sddsFID "&data mode=ascii no_row_counts=1 &end"

    puts $sddsFID "$LMPS(currentTimeFlagPV.var)"
    puts $sddsFID "Local MPS Test Report for APSU Sector $sector"
    puts $sddsFID $sector
    puts $sddsFID $LMPS(startTime)
    
}

proc WriteTestFile {args} {
    set sector 1
    set odd 1
    APSParseArguments {sector odd}
    
    global LMPS
    if $odd {
	set sector1 $sector
	#set txtFID $LMPS(odd.textFID)
	set sddsFID $LMPS(odd.sddsFID)
	set rootname $LMPS(odd.rootname)
	set sect odd
    } else {
	set sector1 [expr $sector + 1]
	set rootname $LMPS(even.rootname)
	set sddsFID $LMPS(even.sddsFID)
	set sect even
    }
    puts "Writing test results to file"
    flush stdout
    puts $sddsFID "$LMPS($sector1.passed)"
    
    for {set chan 1} {$chan<=20} {incr chan} {
	set timestamp [lindex [split $LMPS($sect.chan$chan.timeFlagPV.var) "."] 0]
	puts $sddsFID "$sector1 $chan \"$LMPS(chan$chan.input)\" \"$LMPS(chan$chan.fault)\" \"$timestamp\" $LMPS($sector1.chan$chan.faultTime) $LMPS($sector1.chan$chan.input) $LMPS($sector1.chan$chan.fault) $LMPS($sector1.chan$chan.result)  \"$LMPS(chan$chan.faultDesc)\""

    }
    
    #close $txtFID
    close $sddsFID
    if [catch {exec sddsprintout $rootname.sdds $rootname.txt "-title=" -par=TestDate -par=Description \
		   -col=Sector,format=%5d -col=InputChannel,format=%5d,label=Channel -col=InputName,format=%25s -col=AbortType,format=%15s -col=TimeStamp,format=%20s -col=Result,format=%6s -col=FaultDesc } result] {
	return -code error "Error printout result: $result"
    }
    puts "write file done."
    flush stdout
}

puts "clear all setting..."

ClearAll
after 1000
if [string length $rootname] {
    set LMPS(odd.rootname) $LMPS(dir)/${rootname}-Odd
    set LMPS(even.rootname) $LMPS(dir)/${rootname}-Even
} else {
    set LMPS(odd.rootname) $LMPS(dir)/S[format %02d $sector]-LMPS-[clock format [clock seconds] -format %Y-%m%d]-Odd
    set LMPS(even.rootname) $LMPS(dir)/S[format %02d $sector]-LMPS-[clock format [clock seconds] -format %Y-%m%d]-Even
}

if $odd {
    InitTest -odd 1
    RESET -odd 1
    TestSector -sector $sector -odd 1
    ClearAll
}

if $even {
    InitTest -odd 0
    RESET -odd 0
    TestSector -sector $sector -odd 0
   ClearAll
}

exec caput $LMPS(odd.fastAbortMaskPV) $oddFastMask
exec caput $LMPS(odd.slowAbortMaskPV) $oddSlowMask
exec caput $LMPS(even.fastAbortMaskPV) $evenFastMask
exec caput $LMPS(even.slowAbortMaskPV) $evenSlowMask
after 1000
#reset
exec  caput $LMPS(resetPV) 1
exit 0

	 
