%{

  #ifdef SERVER

	#include "subbus.h"
	#include "collect.h"
	#include "msg.h"

	#include "hpf2soft.h"
	#include "status.h"
	#include "dm5406.h"

	static send_id colsend_id;
	SWDataStruct SWData;

	void sendSWData(){
	    if ( ! colsend_id ) 
		colsend_id = Col_send_init( "SWData", &SWData, sizeof( SWData ) );
	    Col_send(colsend_id);
	} /* sendSWData */

	
	/* Definitions for sending to DCCC */
	#include "cltsrvr.h"
	#include "globmsg.h"
	#include "dccc.h"
	static Server_Def DCdef = { DCCC, 1, 0, 1, 0, 0, 0, 0 };

	unsigned short DigSelect( unsigned short cmd, unsigned short val ) {
	  struct {
		unsigned char type;
		unsigned char dc_type;
		unsigned char cmd;
		unsigned short value;
	  } dcmd;
	  unsigned char rv;
	  
	  dcmd.type = DASCMD;
	  dcmd.dc_type = DCT_DCCC;
	  dcmd.cmd = cmd;
	  dcmd.value = val;
	  if ( !CltSend( &DCdef, &dcmd, &rv, sizeof(dcmd), sizeof(rv) ) ) {
		if ( rv != DAS_OK )
			nl_error( 2, "DCCC returned %d\n", rv );
	  }
	  return val;
	}

  #endif


%}

&command
	: ADIO &ADIO_cmd
	: Data &data_cmd
	: Flow &flow_cmd
	: Run &run_cmd
	: &strb_cmd * { send_dascmd(DCT_SCDC, $1, 0 ); }
	: &set_cmd &on_off * { DigSelect( $1, $2 ); }
	: &set_cmd Set %d (% Full Scale) * {  }
	: Soldrv Select Mode %d (Enter Mode Number) *
		{ send_dascmd(DCT_SOLDRV_A, $4, 0); }
	: XS Flow &xs_cmd 
	: Oxygen Flow &oxygen_cmd 
	: Argon Flow &argon_cmd 
	: Hydrogen Flow &hydrogen_cmd 
	: Purge Flow &purge_cmd 
	: Carrier Flow &carrier_cmd 
	;	
&carrier_cmd
	: On * { DigSelect( 0, 1 ); }
	: Off * { DigSelect( 0, 0 ); }
	: Set %d (% Full Scale) * { }
	;
&xs_cmd
	: On * { DigSelect( 2, 1 ); }
	: Off * { DigSelect( 2, 0 ); }
	: Set %d (% Full Scale) * { 
		unsigned long percentage = $2;
		unsigned short dachannel = 0;
		unsigned short bitval = (percentage * 4096)/100;
		bitval = (bitval > 4095 ) ? 4095 : bitval;
		SWData.F01Set = bitval;
		DM_DAC_Write (dachannel, bitval);
		sendSWData();
	}
	;

&oxygen_cmd
	: On * { DigSelect( 3, 1 ); }
	: Off * { DigSelect( 3, 0 ); }
	: Set %d (% Full Scale) * { 
		unsigned long percentage = $2;
		unsigned short dachannel = 1;
		unsigned short bitval = (percentage * 4096)/100;
		bitval = (bitval > 4095 ) ? 4095 : bitval;
		SWData.F02Set = bitval;
		DM_DAC_Write (dachannel, bitval);
		sendSWData();
	}
	;
&argon_cmd
	: On * { DigSelect( 8, 1 ); }
	: Off * { DigSelect( 8, 0 ); }
	: Set %d (% Full Scale) * { }
	;

&hydrogen_cmd
	: On * { DigSelect( 9, 1 ); }
	: Off * { DigSelect( 9, 0 ); }
	: Set %d (% Full Scale) * { }
	;

&purge_cmd
	: On * { DigSelect( 10, 1 ); }
	: Off * { DigSelect( 10, 0 ); }
	: Set %d (% Full Scale) * { 
		unsigned long percentage = $2;
		unsigned short dachannel = 1;
		unsigned short bitval = (percentage * 4096)/100;
		bitval = (bitval > 4095 ) ? 4095 : bitval;
		SWData.F02Set = bitval;
		DM_DAC_Write (dachannel, bitval);
		sendSWData();
		}
	;
&set_cmd <int>
	: Top FCB Ch 1 Flow { $0 = 0; }
	: Top FCB Ch 3 Flow { $0 = 2; }
	: Top FCB Ch 4 Flow { $0 = 3; }
	: Bottom FCB Ch 1 Flow { $0 = 8; }
	: Bottom FCB Ch 2 Flow { $0 = 9; }
	: Bottom FCB Ch 3 Flow { $0 = 10; }
	;
&strb_cmd <int>
	: &on_off_cmd &on_off { $0 = $1 + 1 - $2; }
	;
&on_off_cmd <int>
	: Switch 0 { $0 = 16; }
	: Switch 1 { $0 = 18; }
	: Manifold Vacuum { $0 = 18; }
	: Switch 2 { $0 = 20; }
	: Manifold Nitrogen { $0 = 20; }
	: Switch 3 { $0 = 22; }
	: Manifold Dual { $0 = 22; }
	: Switch 4 { $0 = 24; }
	: Manifold Bulb 1 { $0 = 24; }
	: Switch 5 { $0 = 26; }
	: Manifold Bulb 2 { $0 = 26; }
	: Switch 6 { $0 = 28; }
	: Manifold Bulb 3 { $0 = 28; }
	: Switch 7 { $0 = 30; }
	: Manifold Main { $0 = 30; }
	: Switch 8 { $0 = 32; }
	: Switch 9 { $0 = 34; }
	: Switch 10 { $0 = 36; }
	: Switch 11 { $0 = 38; }
	: Switch 12 { $0 = 40; }
	: Switch 13 { $0 = 42; }
	: Switch 14 { $0 = 44; }
	: Switch 15 { $0 = 46; }
	;
&on_off <int>
	: On  { $0 = 1; }
	: Off { $0 = 0; }
	;
&data_cmd
	: Soft 1 Set %f * {
		SWData.softFloat1 = $4;
		sendSWData();
		}
	: Soft 2 Set %f * {
		SWData.softFloat2 = $4;
		sendSWData();
		}
	: Soft 3 Set %d * {
		SWData.softInt1 = $4;
		sendSWData();
		}
	;
&ADIO_cmd
        :  Channel %d set %d * {
                unsigned long percentage = $4;
                unsigned int channel = (0xC60 + 2 * $2);
                unsigned short bitval = (percentage * 4096)/100;
                bitval = (bitval >= 4095 ) ? 4095 : bitval;
                switch (channel) {
                        case 0: SWData.DA0Set = bitval; break;
                        case 1: SWData.DA1Set = bitval; break;
                        case 2: SWData.DA2Set = bitval; break;
                        case 3: SWData.DA3Set = bitval; break;
                        case 4: SWData.DA4Set = bitval; break;
                        case 5: SWData.DA5Set = bitval; break;
                        case 6: SWData.DA6Set = bitval; break;
                        case 7: SWData.DA7Set = bitval; break;

                        }
                sbwr (channel, bitval);
		msg(0,"Setting channel %d to %d",channel,bitval);
                sendSWData();
        }
	;
&run_cmd
	: Abort * { 
		SWData.SWStat1 |= ABORTFLAG;
		SWData.SWStat1 &= ~RUNFLAG;	
		sendSWData();
		}
	: Begin * { 
		SWData.SWStat1 |= RUNFLAG;
		SWData.SWStat1 &= ~(ABORTFLAG);
		sendSWData();
		}
	: End * { 
		SWData.scanningCycle = 0; 
		SWData.SWStat1 &= ~RUNFLAG;
		sendSWData();
		}
    : Set Scan Cycle %d * { 
		SWData.scanningCycle = $4; 
		sendSWData();
		}
	;
&flow_cmd
	:  Set %d at %d * { 
		unsigned long percentage = $4;
		unsigned char channel = ($2-1);
		unsigned short bitval = (percentage * 4096)/100;
		bitval = (bitval >= 4095 ) ? 4095 : bitval;
		switch (channel) {
			case 0: SWData.F01Set = bitval; break;
			case 1: SWData.F02Set = bitval; break;
			}
		DM_DAC_Write (channel, bitval);
		sendSWData();
	}
	:  On %d * {
		unsigned char flowNum = 0x1 << ($2-1);
		SWData.DIGIOC |= flowNum;
		DM_WriteDigitalIO(2, ~SWData.DIGIOC);
		sendSWData();
		}
	: Off %d * {
		unsigned char flowNum = 0x1 << ($2-1);
		SWData.DIGIOC &= ~flowNum;
		DM_WriteDigitalIO(2, ~SWData.DIGIOC);
		sendSWData();
		}
	;
&flow_pct <unsigned short>
	: %f (percent full scale) { $0 = (unsigned short)(($1<0) ? 0 : (($1>100) ? 4096 : $1*40.96)); }
	;

&command
	: Adjustable Gate Delay &adjv Width &adjv *
	  { sbwr(0x64E, ($4 << 8) + $6); }
	;
&adjv <unsigned short>
	: %d (Enter 0-255) { $0 = ($1 < 0) ? 0 : (($1 > 255) ? 255 : $1); }
	;