path: root/Software/Stubs Collection/Procedures/Priming1.txt

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Drawing;
using Google.Protobuf;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.PMR.Stubs;
using Tango.PMR.Diagnostics;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Diagnostics;
using Tango.FSE.Procedures;
using System.IO;
using System.Diagnostics;
using System.Windows.Forms;


public class Program
{


private IProcedureContext context;

//---------------------Start Command ----------------
const Int32	CMD_RUN	=	0;		//Run on Pulse Per Secound .positive run Up and negative run Down b
const Int32	CMD_STOP=	1;		//0;Hard stop(Defualt);1-Soft stop;2-Hard Hiz;3-Soft Hiz
const Int32	CMD_VALVE=	2;		//0-to Midtank ,1-to head 
const Int32	CMD_DLY	=	3;		//delay in Seconds .
const Int32	CMD_TIME=	4;		//Print Time .
const Int32	CMD_PRESS=	5;		//return from Delay loop when pressure is high (on mBAR) .
const Int32 CMD_LOOP_NM=6;		//NUMBER OF counter
const Int32 CMD_LOOP=	7;		//jump up(+) or down(-) command  u
const Int32 CMD_MTV_OPEN =	8;		//0 Air ; 1 Ink
const Int32 CMD_MTV_CLOSE=	9;		//0 Air ; 1 Ink
const Int32 CMD_LBL=	10;	//label for user 
const Int32 CMD_SMP=	11; //sample rate ,defualt 100msec  (1); for 1 second is 10.
const Int32 CMD_PRESL=	12; //return from Delay loop when pressure is low (on mBAR) .

const Int32	CMD_END	=	13;	//end loop .
   

Int32[] BuildUp_Table = new int []
{
	CMD_VALVE,1,
	CMD_PRESL,200,
	CMD_DLY,200, 

	CMD_LOOP_NM,3,

	CMD_VALVE,0,
	CMD_DLY,1, 
	CMD_VALVE,1,
	CMD_DLY,1, 
	CMD_LOOP,-4,

	CMD_VALVE,0,
	CMD_RUN,1068,
	CMD_PRESS,1000,	//mbar --> 1000 = 100% work, 4000 = 200% work, 350 = 20% work
	CMD_DLY,150, 		
	CMD_LBL,1,
	CMD_PRESS,2000,	//mbar --> 2000 = 100% work, 4000 = 200% work, 350 = 20% work
	CMD_DLY,60, 		
	CMD_LBL,2,
	CMD_PRESS,3000,
	CMD_DLY,60, // to limit
	CMD_STOP,0,
	CMD_VALVE,1,
	CMD_END,3,
};
	

Int32[] Up_Table = new int []
{
	CMD_VALVE,1,
	CMD_PRESL,200,
	CMD_DLY,200, 
	
	CMD_PRESS,3000,	//mbar --> 1000 = 100% work, 4000 = 200% work, 350 = 20% work
	CMD_RUN,534, // 100%
	CMD_DLY,120,
	CMD_STOP,0,
	CMD_END,3,
};
Int32  Dispenser_sample_rate= 1; 

	string path = @"C:\Dispenser_setup\Log\"; 	
//----------------------
const UInt32 I2C_ID 			=  	4;					//MCU_I2C4 
const UInt32 TCA9548A_address 	=	0xE2;	 	
const UInt32 I2C_Slave_Low_Add 	= 	0xA0;				//eeprom address - 64k low 
const UInt32 I2C_Slave_High_Add = 	0xA2;				//eeprom address - 64k High
//----------------------
byte [] EEPROM_Data = new byte [128];


//---------------------End Command ----------------

const Int32	Dispenser_Motor1	=	6;		 
const Int32	Dispenser_Motor2	=	7;		 
const Int32	Dispenser_Motor3	=	8;		 
const Int32	Dispenser_Motor4	=	9;		 
const Int32	Dispenser_Motor5	=	10;		 
const Int32	Dispenser_Motor6	=	11;		 
const Int32	Dispenser_Motor7	=	12;		 
const Int32	Dispenser_Motor8	=	13;		 

const Int32 AN_IDS_PRESSENS_1	=	2;
const Int32 AN_IDS_PRESSENS_2	=	3;
const Int32 AN_IDS_PRESSENS_3	=	4;
const Int32 AN_IDS_PRESSENS_4	=	5;
const Int32 AN_IDS_PRESSENS_5	=	6;
const Int32 AN_IDS_PRESSENS_6	=	7;
const Int32 AN_IDS_PRESSENS_7	=	8;
const Int32 AN_IDS_PRESSENS_8	=	9;

const Int32	F2_LS_01_Direct	=	0x60000420	;	//	Reads the direct values that are currently being sent to the fpga.	rsv		rsv		rsv						rsv						F2_LS_DISPENSER_UP_2	F2_LS_DISPENSER_25_2	F2_LS_DISPENSER_75_2	F2_LS_DISPENSER_DOWN_2 	F2_LS_DISPENSER_50_2	F2_LS_DISPENSER_SPARE_2	F2_LS_DISPENSER_UP_1	F2_LS_DISPENSER_25_1 	F2_LS_DISPENSER_75_1	F2_LS_DISPENSER_DOWN_1	F2_LS_DISPENSER_50_1	F2_LS_DISPENSER_SPARE_1			
const Int32	F2_LS_02_Direct	=	0x60000430	;	//	Reads the direct values that are currently being sent to the fpga.	rsv		rsv		rsv						rsv						F2_LS_DISPENSER_UP_4	F2_LS_DISPENSER_25_4	F2_LS_DISPENSER_75_4	F2_LS_DISPENSER_DOWN_4	F2_LS_DISPENSER_50_4	F2_LS_DISPENSER_SPARE_4	F2_LS_DISPENSER_UP_3	F2_LS_DISPENSER_25_3 	F2_LS_DISPENSER_75_3	F2_LS_DISPENSER_DOWN_3	F2_LS_DISPENSER_50_3	F2_LS_DISPENSER_SPARE_3			
const Int32	F2_LS_03_Direct	=	0x60000440	;	//	Reads the direct values that are currently being sent to the fpga.	rsv		rsv		rsv						rsv						F2_LS_DISPENSER_UP_6  	F2_LS_DISPENSER_25_6  	F2_LS_DISPENSER_75_6  	F2_LS_DISPENSER_DOWN_6	F2_LS_DISPENSER_50_6	F2_LS_DISPENSER_SPARE_6	F2_LS_DISPENSER_UP_5	F2_LS_DISPENSER_25_5 	F2_LS_DISPENSER_75_5	F2_LS_DISPENSER_DOWN_5	F2_LS_DISPENSER_50_5	F2_LS_DISPENSER_SPARE_5			
const Int32	F2_LS_04_Direct =	0x60000480	;	//	Reads the direct values that are currently being sent to the fpga.	rsv		rsv		rsv						rsv						F2_LS_DISPENSER_UP_8	F2_LS_DISPENSER_25_8	F2_LS_DISPENSER_75_8	F2_LS_DISPENSER_DOWN_8	F2_LS_DISPENSER_50_8	F2_LS_DISPENSER_SPARE_8	F2_LS_DISPENSER_UP_7	F2_LS_DISPENSER_25_7 	F2_LS_DISPENSER_75_7	F2_LS_DISPENSER_DOWN_7	F2_LS_DISPENSER_50_7	F2_LS_DISPENSER_SPARE_7			

const Int32 Dispenser_Valve1	=	0;
const Int32 Dispenser_Valve2	=	1;
const Int32 Dispenser_Valve3	=	2;
const Int32 Dispenser_Valve4	=	3;
const Int32 Dispenser_Valve5	=	4;
const Int32 Dispenser_Valve6	=	5;
const Int32 Dispenser_Valve7	=	6;
const Int32 Dispenser_Valve8	=	7;

const ushort MinPress_Mbar_Add =0x5c ;
const ushort MaxPress_Mbar_Add =0x60 ;

const  Int32 F3_VALVE_OUT	= 0x600000e2;		

//string path = "C:\\Dispenser_setup\\Log\\"; 


//Int32[] Start_Table;

Int32[] Start_Table = new Int32 [10000];

UInt32 [] Motor_Dir=new UInt32 [8] {0,0,0,0,0,0,0,0};

string Dispenser_Fname ;

Int32  Dispenser_ptr =-1;

Int32 [] Dispenser_press= new Int32[8]{0,0,0,0,0,0,0,0};
Int32 max_pressure_level = 20000;
Int32 min_pressure_level = -20000;
	
Int32 [] A2D_Dispenser= new Int32[8]{0,0,0,0,0,0,0,0};
Int32  Loop_cnt= 1;
Int32  Loop_length=1;

Int32  PressureSensorType= 1;		//1- new -1up +10 . 0-old 0 to +10
Int32	Temp_Delay=0;


UInt32 RD_LS_01_Direct;
UInt32 RD_LS_02_Direct;
UInt32 RD_LS_03_Direct;
UInt32 RD_LS_04_Direct;

long Lebel1_time;
long Lebel2_time;

long time_Table;

Int32 msec_index=0;

Int32 MaxPress_Mbar;
Int32 MinPress_Mbar;
string state;

	public Int32  OnExecute(IProcedureContext context)
    {
		long Max_PBU;
		Int32 Index=0;
		Int32 speed=0;
		Int32 Dispenser_Nm;
		this.context = context;
	
		string box_msg = "Make sure Mixer Hot ";
		MessageBox.Show(box_msg);
		
		var response1 = context.RequestUserInputFor<String>("Dispenser Number", "Enter Dispenser number to make priming  (1-8):");
		context.WriteLine(response1);
		Dispenser_Nm = Int32.Parse(response1);
		
		check_Min_Max_Mbar(Dispenser_Nm);
	
		if (Dispenser_Nm==8)
			Max_PBU=6000;
		else
			Max_PBU=4000;
			
	
	if (!Directory.Exists(path))
		{
			Directory.CreateDirectory(path);
		}	
			context.WriteLine(path);
			
	context.Send<ProgressResponse>("ProgressRequest" ,0xe0, 1);

	Dispenser_Fname=path + "Dispenser_Nm_" + Dispenser_Nm+"_" + DateTime.Now.ToString("MM-dd-yy hh-mm")+ ".csv" ;

	context.WriteLine(Dispenser_Fname);

	context.WriteToFile(Dispenser_Fname,"Dispenser Nm,"   + Dispenser_Nm + "\n" );
	context.AppendToFile(Dispenser_Fname,"Pressure,Command,Value,DateTime,Remark\n" ); 
		for(int j=0; j<2;j++)
		{
			for(int i=0; i<4;i++)
			{
				state="PBU No. "+ (4*j+i+1 );
				Start_Table=BuildUp_Table;
				Table_Run(Dispenser_Nm );
				if (time_Table>300000)
				{
					context.AddResult(ResultType.Failed,"PBU", "PBU No."+ (4*j+i+1 ) + "  Fail");
					return 0;
				}
				   context.AddResult(ResultType.Passed,"PBU","PBU No."+ (4*j+i+1 ) + "  Pass");
					
			}
			state="Flow No."+ (j+1 ) ;
			Start_Table=Up_Table;
			Table_Run(Dispenser_Nm );
			if (time_Table<115000)
				{
					context.WriteLine("time_Table= " +time_Table);
					context.AddResult(ResultType.Failed,"Flow", "Flow No."+ (j+1) + "  Fail");
					return 0;
				}
				   context.AddResult(ResultType.Passed,"Flow","Flow No."+ (j+1 ) + "  Pass");
						
		}
				   state="Last PBU " ;
				Start_Table=BuildUp_Table; 
				Table_Run(Dispenser_Nm );
				long Time=Lebel2_time-Lebel1_time;
				if (Time>Max_PBU)
				   {    
				   context.AddResult(ResultType.Failed,"PBU", "PBU = " +Time  + "msec ");
				   state="PBU = " +Time  + "msec \tFail";
				   }
				else
				{
				   context.AddResult(ResultType.Passed,"PBU", "PBU = " +Time  + "msec ");
				   state="PBU = " +Time  + "msec \tPass";
				}	
		return 0;
		
    }

/////////////////////////////////////////////
void 		check_Min_Max_Mbar(Int32 i )
{
	int k;
	string s ;
	i--;

					context.WriteLine("-------------- write Enable Channel ------------");	//debug
		enable_channel(i); // Chanel 0-7 => Disp0enser 0-7 
					context.WriteLine("-------------- Read_header ------------");	//debug

					context.WriteLine("-------------- write_address_eeprom ------------");	//debug
		write_address_eeprom (I2C_Slave_Low_Add,MinPress_Mbar_Add);
					context.WriteLine("-------------- read_data_from_eeprom ------------");	//debug
		read_data_from_eeprom (I2C_Slave_Low_Add,1);
		if 	(EEPROM_Data[0]==0	)
		{	PressureSensorType=0;
			context.WriteLine("PressureSensorType=0" );	//debug
		}
		else	
		{	
			PressureSensorType=1;					
			context.WriteLine("PressureSensorType=1" );	//debug
		}
	
}	
//----------------write address eeprom -------------------------
public void write_address_eeprom (UInt32 I2C_Add, UInt32 Eeprom_Add)
{	
	StubI2CWriteBytesRequest stubI2CWriteBytesRequest = new StubI2CWriteBytesRequest();
	stubI2CWriteBytesRequest.I2CId = I2C_ID;
	stubI2CWriteBytesRequest.SlaveAddress = I2C_Add;
	
	UInt32 uInt32 = new UInt32();
	stubI2CWriteBytesRequest.BytesTWrite.Add(Convert.ToByte( (Eeprom_Add & 0xff00) >>8));	//Byte High add to write
	stubI2CWriteBytesRequest.BytesTWrite.Add(Convert.ToByte(Eeprom_Add & 0xff));			//Byte Low  add to write
					context.WriteLine( (Eeprom_Add & 0xff00) >>8) ;	//debug
					context.WriteLine( Eeprom_Add & 0xff);	//debug

	context.Send<StubI2CWriteBytesResponse>(stubI2CWriteBytesRequest);	
}
//------------------- read Data from EEprom--------------------------

public void read_data_from_eeprom ( UInt32 I2C_Add, UInt32 cnt )
{
	StubI2CReadBytesRequest stubI2CReadBytesRequest = new StubI2CReadBytesRequest();
	stubI2CReadBytesRequest.I2CId = I2C_ID;
	stubI2CReadBytesRequest.SlaveAddress = (I2C_Add + 1);
	stubI2CReadBytesRequest.NumberOfBytesToRead = cnt; // Number of bytes to read

	var response1 = context.Send<StubI2CReadBytesResponse>(stubI2CReadBytesRequest);

	for(int i=0; i<cnt;i++)
		{
			EEPROM_Data[i]=Convert.ToByte(response1.ReadBytes[i]);
			context.WriteLine(EEPROM_Data[i] );	//debug

		}		
}	


///////////////////////////////////////////////
//----------- enable I2c channel --------------
public int enable_channel(Int32 Channel_ID) 
{
	uint Const_temp = 0x01;	
	
	StubI2CWriteBytesRequest stubI2CWriteBytesRequest = new StubI2CWriteBytesRequest();
	stubI2CWriteBytesRequest.I2CId = I2C_ID;
	stubI2CWriteBytesRequest.SlaveAddress = TCA9548A_address;
	
	Const_temp = Const_temp << Channel_ID;
	stubI2CWriteBytesRequest.BytesTWrite.Add(Const_temp);//enable i2c channel 0 Dispenser 1

	var response = context.Send<StubI2CWriteBytesResponse>(stubI2CWriteBytesRequest);
	
	return 1;
}


//////////////////////////////////////////////////////////////    
Int32 Table_Run(Int32 Dispenser )

{
	Int32 COMMAND=0;
	Int32 Data=0;
	Int32 count=0;
	
	Dispenser--;		//check from 0-7
	
	int j=0;
	var stopwatch = new Stopwatch();
		stopwatch.Start();
	
		long elapsed_time = stopwatch.ElapsedMilliseconds;
		context.WriteLine(elapsed_time);
		
	while (count!=-1)   
	{
	msec_index=msec_index+1;
		
		if (Dispenser<2) 
			{
				var response1 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_01_Direct);
				RD_LS_01_Direct=response1.Value	 ;
			}
		else if ( (Dispenser<4) )
			{
				var response1 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_02_Direct);
				RD_LS_02_Direct=response1.Value	 ;
			}
		else if ( (Dispenser<6) )
			{
				var response1 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_03_Direct);
				RD_LS_03_Direct=response1.Value	 ;
			}
		else
			{
				var response1 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_04_Direct);
				RD_LS_04_Direct=response1.Value	 ;
			}
		if (Dispenser<4) 
			{
			var response2 = context.Send<StubIntADCReadResponse>("StubIntADCReadRequest" ,0x8000 + AN_IDS_PRESSENS_1);
				A2D_Dispenser[0]=(response2.SamplingInBits)>>16;
				A2D_Dispenser[1] =(response2.SamplingInBits) & 0x0000ffff;
				A2D_Dispenser[2] =(response2.VoltageSamplingMv)>>16;
				A2D_Dispenser[3] =(response2.VoltageSamplingMv) & 0x0000ffff;
			}
		else
			{
			var	response3 = context.Send<StubIntADCReadResponse>("StubIntADCReadRequest" ,0x8000 + AN_IDS_PRESSENS_5);
				A2D_Dispenser[4] =(response3.SamplingInBits)>>16;
				A2D_Dispenser[5] =(response3.SamplingInBits)& 0x0000ffff;
				A2D_Dispenser[6] =(response3.VoltageSamplingMv)>>16;
				A2D_Dispenser[7] =(response3.VoltageSamplingMv)& 0x0000ffff;
			}
				
			COMMAND=Start_Table[count];
			Data=Start_Table[(count+1)];
																		//Index=Index+2;
			switch (COMMAND)
				{
				case CMD_RUN:
					Motor_Run(Data,Dispenser);
					count = count+2;
					break;
					
				case CMD_VALVE:
					Valve_3W(Data,Dispenser);
					count = count+2;
					break;
					
				case CMD_STOP:
					Motor_Stop(Data,Dispenser);
					count = count+2;
					break;
					
				case CMD_DLY:
					Delay_on_second(Data,Dispenser);
					if (Temp_Delay ==0)
					{
						max_pressure_level=20000;	
						min_pressure_level=-20000;	
						count = count+2;
					}
					break;
					
				case CMD_TIME:
					Print_Time();
					count = count+2;
					break;
					
				case CMD_PRESS:
					max_pressure_level=Data;
					context.AppendToFile(Dispenser_Fname,",Max_pressure_level is, " + Data +","+DateTime.Now+"\n");
					count = count+2;
					break;
					
				case CMD_PRESL:
					min_pressure_level=Data;
					context.AppendToFile(Dispenser_Fname,",Min_pressure_level is, " + Data +","+DateTime.Now+"\n");
					count = count+2;
					break;
					
				case CMD_LBL:														
					context.AppendToFile(Dispenser_Fname,",Label," + Data+","+DateTime.Now+"\n");
					if(Data==1)
						Lebel1_time=stopwatch.ElapsedMilliseconds;
					if(Data==2)
						Lebel2_time=stopwatch.ElapsedMilliseconds;
					count = count+2;
					break;
					
					
				case CMD_SMP:														
					context.AppendToFile(Dispenser_Fname,",SampleRate," + Data+","+DateTime.Now+"\n");
					Dispenser_sample_rate =Data;
					count = count+2;
					break;
					
				case  CMD_END:
					count=-1;
					context.AppendToFile(Dispenser_Fname,",End testing,,"+DateTime.Now+"\n");
					break;
				
				case  CMD_MTV_OPEN:
					open_midtank_valve(Data,Dispenser);
					context.AppendToFile(Dispenser_Fname,",OPEN MIDTANK, " + Dispenser+","+DateTime.Now+"\n");
					count = count+2;
					break;

				case  CMD_MTV_CLOSE:
					close_midtank_valve(Data,Dispenser);
					context.AppendToFile(Dispenser_Fname,",CLOSE MIDTANK, " + Dispenser+","+DateTime.Now+"\n");
					count = count+2;
					break;
				
				case  CMD_LOOP_NM:
				
					Loop_cnt=Data-1;
					context.AppendToFile(Dispenser_Fname,",Counter Loop,"+ Data+","+DateTime.Now +"\n");
					count = count+2;						
					break;

				case  CMD_LOOP:
				
					if (Loop_cnt!=0)
						{
						context.AppendToFile(Dispenser_Fname,"Counter Loop,"+ Loop_cnt+","+DateTime.Now+"\n" );
						count = count+2*Data;
						Loop_cnt--;
						
						}
					else
						{
						context.AppendToFile(Dispenser_Fname,",End loop,,"+DateTime.Now +"\n");
						count = count+2;	
						}
					break;

				default:
					break;

			}	
			
			long elapsed_time1 = stopwatch.ElapsedMilliseconds;
			long elapsed_time2= elapsed_time1-elapsed_time;
			if (elapsed_time2>95)
			elapsed_time2=95;		//minimum time
				Thread.Sleep(100-(int )(elapsed_time2));

			elapsed_time = stopwatch.ElapsedMilliseconds;		


			j++;
				if (j==10)
				{
					j=0;
					context.WriteLine(Dispenser_press[Dispenser]+ " mBar\t"+state + "\tTime-" + (elapsed_time/1000));
				}
	}
	time_Table=elapsed_time;
	return 0;
}

///////////////////////////////////////////////////////////////////	
Int32 Motor_Run(Int32 speed,Int32 Dispenser)

{

	switch (Dispenser)
		{
		case 0:
				if ( speed<0)
				{
					Motor_Dir[0]=2;
					if ((RD_LS_01_Direct & 0x04)!=0x04)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor1, false, (-speed));
				}
				else
				{	
					Motor_Dir[0]=1;
					if ((RD_LS_01_Direct & 0x20)!=0x20)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor1, true, (speed));
				}
			break;

		case 1:
				if ( speed<0)
				{
					Motor_Dir[1]=2;
					if ((RD_LS_01_Direct & 0x100)!=0x100)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor2, false, (-speed));
				}
				else
				{	
					Motor_Dir[1]=1;
					if ((RD_LS_01_Direct & 0x800)!=0x800)
					{						
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor2, true, (speed));
				}
			break;

		case 2:
				if ( speed<0)
				{
					Motor_Dir[2]=2;
					if ((RD_LS_02_Direct & 0x04)!=0x04)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor3, false, (-speed));
				}
				else
				{	
					Motor_Dir[2]=1;
					if ((RD_LS_02_Direct & 0x20)!=0x20)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now+ ",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor3, true, (speed));
				}
			break;

		case 3:
				if ( speed<0)
				{
					Motor_Dir[3]=2;

					if ((RD_LS_02_Direct & 0x100)!=0x100)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now+ ",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor4, false, (-speed));
				}
				else
				{	
					Motor_Dir[3]=1;

					if ((RD_LS_02_Direct & 0x800)!=0x800)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor4, true, (speed));
				}
			break;
		
		case 4:
				if ( speed<0)
				{
					Motor_Dir[4]=2;
					if ((RD_LS_03_Direct & 0x04)!=0x04)
					{  
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now+ ",Warning Motor on Limit\n");
						return 0;
					}
					
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor5, false, (-speed));
				}
				else
				{	
					Motor_Dir[4]=1;
					if ((RD_LS_03_Direct & 0x20)!=0x20)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now+ ",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor5, true, (speed));
				}
			break;

		case 5:
				if ( speed<0)
				{
					Motor_Dir[5]=2;
					if ((RD_LS_03_Direct & 0x100)!=0x100)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor6, false, (-speed));
				}
				else
				{	
					Motor_Dir[5]=1;
					if ((RD_LS_03_Direct & 0x800)!=0x800)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now+ ",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor6, true, (speed));
				}
			break;

		case 6:
				if ( speed<0)
				{
					Motor_Dir[6]=2;
					if ((RD_LS_04_Direct & 0x04)!=0x04)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor7, false, (-speed));
				}
				else
				{	
					Motor_Dir[6]=1;
					if ((RD_LS_04_Direct & 0x20)!=0x20)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor7, true, (speed));
				}
			break;

		case 7:
				if ( speed<0)
				{
					Motor_Dir[7]=2;

					if ((RD_LS_04_Direct & 0x100)!=0x100)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor8, false, (-speed));
				}
				else
				{	
					Motor_Dir[7]=1;

					if ((RD_LS_04_Direct & 0x800)!=0x800)
					{
						context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Motor on Limit\n");
						return 0;
					}
					context.Send<StubMotorRunResponse>("StubMotorRunRequest" ,Dispenser_Motor8, true, (speed));
				}
			break;
			
		default:
			break;

		}
  	context.AppendToFile(Dispenser_Fname,",Run," +speed+","+DateTime.Now +"\n" );                                                                                                           

	return 1;
}    
    
 	
 Int32 Valve_3W(Int32 Valve_Value,Int32 Dispenser)
{
	if ( Valve_Value==1)
		context.Send<StubValveResponse>("StubValveRequest" ,Dispenser_Valve1+Dispenser, 3, true);	//3 3Way
	else	
		context.Send<StubValveResponse>("StubValveRequest" ,Dispenser_Valve1+Dispenser, 3, false);  //3 3Way
 
	context.AppendToFile(Dispenser_Fname,",Dispenser Valve position is, " + Valve_Value+","+DateTime.Now +"\n" );

	return 1;	
}	
//---------------------------------------    

 Int32 Motor_Stop(Int32 Stop_Value,Int32 Dispenser )
{
	context.Send<StubMotorStopResponse>("StubMotorStopRequest" ,Dispenser_Motor1+Dispenser, Stop_Value);
	
	context.AppendToFile(Dispenser_Fname,",Motor Stop," + Stop_Value+","+DateTime.Now +"\n");
	Motor_Dir[Dispenser]=0;
	return 1;	
}

//---------------------------------------    

 Int32 Delay_on_second(Int32 Delay,Int32 Dispenser )
{
//Int32 temp1;
Int32 pressure_om_mBAR=0;
	if 	(Temp_Delay ==0)
	{
		context.AppendToFile(Dispenser_Fname,",DLY, " + Delay +","+DateTime.Now+"\n");
		Temp_Delay = Delay *10 -1;
//														context.Write("A");		//debug
	}
	else	
			Temp_Delay--;
			
	if ( LimitSW_Dispenser(Dispenser)==0)
 	    {	
 	    	context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now+",Warning Motor on Limit\n");
			MotorStop(Dispenser);
			Temp_Delay =0;	//end delay
//																	context.Write("C");		//debug

			return 0 ;
 	    }
					
	pressure_om_mBAR=Calc_mBAR(Dispenser,true);
  	if (pressure_om_mBAR > max_pressure_level)
 	 	{
		//	MotorStop(Dispenser);
			context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Pressure too high\n");
			Temp_Delay =0;	//end delay
//																	context.Write("D");		//debug
			
			return 0;
		}
  	if (pressure_om_mBAR < min_pressure_level)
 	 	{
		//	MotorStop(Dispenser);
			context.AppendToFile(Dispenser_Fname,",,,"+DateTime.Now +",Warning Pressure too low\n");
			Temp_Delay =0;	//end delay
//																	context.Write("D");		//debug
			
			return 0;
		}
		
		
  	return 1;
}	
    	   	
Int32 LimitSW_Dispenser(Int32 Dispenser) 
{

	if (Dispenser==0)
		
		{
			
//		var response1 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_01_Direct);

				if (((RD_LS_01_Direct & 0x04)!=0x04) && (Motor_Dir[0]==2))
						return 0;
					else
				if (((RD_LS_01_Direct & 0x20)!=0x20) && (Motor_Dir[0]==1))
						return 0;
					else
				return 1;		
		}
		
	if (Dispenser==1)
		
		{
//		var response2 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_01_Direct);
				if (((RD_LS_01_Direct & 0x100)!=0x100) && (Motor_Dir[1]==2))
						return 0;
					else
				if (((RD_LS_01_Direct & 0x800)!=0x800) && (Motor_Dir[1]==1))
						return 0;
					else
				return 1;		
		}
		

	if (Dispenser==2)
		
		{
				
		//var response3 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_02_Direct);
				if (((RD_LS_02_Direct & 0x04)!=0x04) && (Motor_Dir[2]==2))
						return 0;
					else
				if (((RD_LS_02_Direct & 0x20)!=0x20) && (Motor_Dir[2]==1))
						return 0;
					else
				return 1;		
			
		}
		
	if (Dispenser==3)
		
		{
				var response4 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_02_Direct);
				if (((RD_LS_02_Direct & 0x100)!=0x100) && (Motor_Dir[3]==2))
						return 0;
					else
				if (((RD_LS_02_Direct & 0x800)!=0x800) && (Motor_Dir[3]==1))
						return 0;
					else
				return 1;		
		}
		
		
		

	if (Dispenser==4)
		
		{
			
//		var response1 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_01_Direct);
				if (((RD_LS_03_Direct & 0x04)!=0x04) && (Motor_Dir[4]==2))
						return 0;
					else
				if (((RD_LS_03_Direct & 0x20)!=0x20) && (Motor_Dir[4]==1))
						return 0;
					else
				return 1;		
		}
		
	if (Dispenser==5)
		
		{
//		var response2 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_01_Direct);
				if (((RD_LS_03_Direct & 0x100)!=0x100) && (Motor_Dir[5]==2))
						return 0;
					else
				if (((RD_LS_03_Direct & 0x800)!=0x800) && (Motor_Dir[5]==1))
						return 0;
					else
				return 1;		
		}
		

	if (Dispenser==6)
		
		{
				
		//var response3 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_02_Direct);
				if (((RD_LS_04_Direct & 0x04)!=0x04) && (Motor_Dir[6]==2))
						return 0;
					else
				if (((RD_LS_04_Direct & 0x20)!=0x20) && (Motor_Dir[6]==1))
						return 0;
					else
				return 1;		
			
		}
		
	if (Dispenser==7)
		
		{
//		var response4 = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F2_LS_02_Direct);
				if (((RD_LS_04_Direct & 0x100)!=0x100) && (Motor_Dir[7]==2))
						return 0;
					else
				if (((RD_LS_04_Direct & 0x800)!=0x800) && (Motor_Dir[7]==1))
						return 0;
					else
				return 1;		
		}
		
		
		return 0;
}		
		
	    	
Int32 Print_Time() 
{	
		context.AppendToFile(Dispenser_Fname,",Time is\t,,"+ DateTime.Now +"\n" );                                                                                           

		return 1;
}	



Int32 Calc_mBAR(Int32 Dispenser, bool save_press)
{		
Int32 Data;
Int32 Sense1;
Int32 temp=0;

		Data =A2D_Dispenser[Dispenser];
		if (Data<100)
			temp=-1;
		Data=Data-710;
		if (Data<0)
		Data=0;

		Data=Data*(10000+PressureSensorType*1000)/2840;	//	for -1 to 10 bar Press_Sensor_Type=1 else 0
		Data=Data-1000*PressureSensorType;   			//  for -1 to 10 bar

		if (temp==-1)						//if SamplingInBits <100 then No pressure sensor exist
		Sense1=-9999	;
		else	
		Sense1=Data	;
		if (	((msec_index) % (Dispenser_sample_rate)) == 0)
		{
			context.AppendToFile(Dispenser_Fname,"" + Sense1+"\n");
		}
		Dispenser_press[Dispenser]=Sense1;
	return Sense1;
			
 }   	

   
//--------------------------------
int open_midtank_valve (Int32 valve_type,Int32 valve_nm)		//valve_type=0 is Air ,1 is Ink ; valve_nm 0-7
{
	SetBit (F3_VALVE_OUT,((valve_type+1)*8)- valve_nm-1, 1);
	return 1;

}
//--------------------------------	
int close_midtank_valve (Int32 valve_type,Int32 valve_nm)		//valve_type=0 is Air ,1 is Ink ; valve_nm 0-7
{
	SetBit (F3_VALVE_OUT,((valve_type+1)*8)- valve_nm-1, 0);
	return 1;
}
//--------------------------------
Int32 SetBit(Int32 Adr, Int32 BitNo, Int32 Bit)
{
	Int32 BitMask;

    var response = context.Send<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" , F3_VALVE_OUT);
	Int32 RV = (Int32) response.Value & 0xffff;
	
	
	if (Bit == 0x1) 
	{
		BitMask = 0x1 << BitNo;
		RV = RV | BitMask;
		context.Send<StubFpgaWriteRegResponse>("StubFpgaWriteRegRequest" ,F3_VALVE_OUT , RV);
	}
	else if (Bit == 0x0)
	{
		BitMask = ~(0x1 << BitNo);
		RV = RV & BitMask;
		context.Send<StubFpgaWriteRegResponse>("StubFpgaWriteRegRequest" ,F3_VALVE_OUT , RV);
	}
	return 1;
}
//----------------------------------    
 void MotorStop(Int32 i)
{
 
context.Send<StubMotorStopResponse>("StubMotorStopRequest" ,Dispenser_Motor1+i, 2);
Motor_Dir[i]=0;	//0 stop 1- up 2-dn

}
    
}