#hpf control algorithm -- nmd
#Revision history (ha ha)
# 6 jul 96 (nmd) porting to tma2
# 15 jul 96 (nmd) slurpable modulation scripts working

State InitializeHPF {
    > Telemetry start
    Validate Standby;
}

State Standby{
    {
        if ( runHasBegun(HPFStat) ){
                if ( maskVal(HPFStat,PLUME_BIT) ){ Validate Plume; }
                else if ( maskVal(HPFStat,ZERO_BIT) ){ Validate Zero; }
                else if ( maskVal(HPFStat,LASER_BIT) ){ 
                        Validate ProductRun; }
                else{ Validate Run; }
                } 
    }
    "";
}

State Between_Runs{
    { if ( runWasAborted(HPFStat) ) validate Standby; }
    1:44 > Log Check for run in queue.
    1:45 { if ( ! runPending() ) validate Standby; }
    1:59 > Log Start the run
    2:00 { Validate Run; }
}

State Run "run.alg" {
    { if ( runHasEnded(HPFStat) ) Validate Between_Runs; }
}

State Zero "zero.alg" {
    { if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State Plume "plume.alg" {
    { if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Type Run End to end the plume run";
}

State ProductRun{
    0:01		Validate InitializeScanning;
    0:05		Validate CheckProductCycle;
}

State CheckProductCycle{
    { if ( runHasEnded(HPFStat) ) Validate Standby;}
    { if (scanInfo.scanNumber > scanInfo.maxScans ) Validate Standby; } 
    0:05		Validate ModulationStage0;
}
	
State ModulationStage0Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage0;	
}

State ModulationStage0 "modulationStage0.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage1Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage1;	
}

State ModulationStage1 "modulationStage1.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage2Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage2;	
}

State ModulationStage2 "modulationStage2.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage3Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage3;	
}

State ModulationStage3 "modulationStage3.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage4Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage4;	
}

State ModulationStage4 "modulationStage4.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage5Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage5;	
}

State ModulationStage5 "modulationStage5.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage6Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage6;	
}

State ModulationStage6 "modulationStage6.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage7Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage7;	
}

State ModulationStage7 "modulationStage7.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage8Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage8;	
}

State ModulationStage8 "modulationStage8.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage9Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage9;	
}

State ModulationStage9 "modulationStage9.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage10Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage10;	
}

State ModulationStage10 "modulationStage10.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage11Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage11;	
}

State ModulationStage11 "modulationStage11.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage12Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage12;	
}

State ModulationStage12 "modulationStage12.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage13Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage13;	
}

State ModulationStage13 "modulationStage13.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage14Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage14;	
}

State ModulationStage14 "modulationStage14.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage15Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage15;	
}

State ModulationStage15 "modulationStage15.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage16Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage16;	
}

State ModulationStage16 "modulationStage16.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage17Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage17;	
}

State ModulationStage17 "modulationStage17.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage18Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage18;	
}

State ModulationStage18 "modulationStage18.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

State ModulationStage19Wait {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
    "Waiting for scan to end";
     0:00 Hold until valid (ScanningComplete);
    Validate ModulationStage19;	
}

State ModulationStage19 "modulationStage19.alg" {
    {if ( runHasEnded(HPFStat) ) Validate Standby; }
}

partition
############################################################
#
#  This defines the modulation cycles
#
############################################################

State InitializeScanning {
    { if ( ! initScanInfo(&scanInfo) ) Validate Standby; }
    Validate scanningComplete;
    } 

State EnqueueFromScanInfo {
    {scanInfo.resolutionNumber++;}
    {if (scanInfo.resolutionNumber > scanInfo.numberOfResolutions )
		    Validate ScanningComplete;
		else
		    Validate StartScanInfoScan;}
    }

State StartScanInfoScan {
    {readScanInfo(&scanInfo); }
    {enqueueFTIRScan(&scanInfo);}
    Validate ScanInfoScanInProgress; 
   }

State ScanInfoScanInProgress {
    depending on (1 Hz){
	if ( ++delayCounter == scanInfo.pollingInterval ) {
	    delayCounter = 0;
	    if ( scanCompleted(&scanInfo) ){
		    Validate EnqueueFromScanInfo;
		    }
		}
	    }	
    "Waiting for scan to end";
    }

State ScanInProgress {
    "Waiting for scan to end";
    depending on (1 Hz){ if ( scanCompleted(&scanInfo) ){
		    Validate ScanningComplete;
		    }
	    }	
    }

State ScanningComplete {
    {scanInfo.scanNumber++; }
    {scanInfo.resolutionNumber=0;}
    0:00 > XS Reagent Set Scan Cycle 0
    }

partition
############################################################
#
#  This defines the chop mode for the laser
#
############################################################


State noChopping{
}

State Chopping{
		> Laser Background
	+0:15	> Laser Online
	+0:15	{Validate Chopping;}
}

partition
############################################################
#
#  This defines the drive mode for the laser
#
############################################################

%{
typedef struct {
    unsigned int steps[3];
    unsigned int counts[3];
} peakUpStruct;

static peakUpStruct aPeak;
static short peakUpCtr;
%}

State etalonAtRest {
	0:00 Hold until ( SWEtalonMove != 0 );
	Validate driveEtalon;
}

State driveEtalon {
	> Laser Step
	Validate etalonAtRest;
}

State peakUp {
	{if (! SWLineWidth) Validate etalonAtRest;}
	{ aPeak.counts[0] = peakUpCtr = 0;}
	{ aPeak.steps[0] = SWEtalonPos; }
	hold until ( aPeak.counts[0] += Correct1, peakUpCtr++ < 5 );
    	{ci_sendfcmd(0,"Laser Move %d\n",SWLineWidth); }
	+ 0:01  >
	{ aPeak.counts[1] = peakUpCtr = 0;}
	{ aPeak.steps[1] = SWEtalonPos; }
	hold until ( aPeak.counts[1] += Correct1, peakUpCtr++ < 5 );
    	{ci_sendfcmd(0,"Laser Move %d\n",- 2 *SWLineWidth); }
	+ 0:01  >
	{ aPeak.counts[1] = peakUpCtr = 0;}
	{ aPeak.steps[1] = SWEtalonPos; }
	hold until ( aPeak.counts[1] += Correct1, peakUpCtr++ < 5 );
}

partition
############################################################
#
#  Pressure control
#
############################################################

%{
static short pDelayCounter;
static float pTotOld;
static float pFCSet;
static float pFCSetOld;
%}



State noPressureControl {
    { if ( SWPSysSet > 0 ) {
         pTotOld = convert(P_MAN);
	 pFCSet = 0.0;
     	 ci_sendfcmd(0,"oH Source Makeup Flow set %f\n",pFCSet); 
	 ci_sendfcmd(0,"oH Source Makeup Flow off\n"); 
         Validate controlPressure;
         }
    }
}

State controlPressure {
    + 0:01 > Log  Controlling Pressure
    depending on (1 Hz) { 
        if ( SWPSysSet <= 0 ) {
           pDelayCounter = 0;
           Validate noPressureControl;
        }
        if ( ++pDelayCounter >= SWPPhase ) {
           pDelayCounter = 0;
	   pFCSetOld = pFCSet;
           pFCSet = pFCSet + (SWPGain*((2*convert(P_MAN))-pTotOld-SWPSysSet )* 7.002/(SWPFCFullScale*SWPPhase) );
           ci_sendfcmd(0,"Log pFCSet now set to %f\n",pFCSet);
           if ( pFCSet > SWPFCMax ) {
               pFCSet = SWPFCMax;
               ci_sendfcmd(0,"Log pressure control wants more flow than possible\n");
           }
           if ( pFCSet < SWPFCMin ) {
               pFCSet = SWPFCMin;
               ci_sendfcmd(0,"Log pressure control wants less flow than possible\n");
           }
           ci_sendfcmd(0,"oH Source Makeup Flow set %f\n",pFCSet); 
           ci_sendfcmd(0,"oH Source Makeup Flow on\n"); 
           pTotOld = convert(P_MAN);
           ci_sendfcmd(0,"Log pTotOld now set to %f\n",pTotOld);
        }
    }
}