updated procedures in FSE testing and PROD

1 files changed, 1015 insertions, 0 deletions

diff --git a/Software/Stubs Collection/Procedures/Priming1.txt b/Software/Stubs Collection/Procedures/Priming1.txt
new file mode 100644
index 000000000..adfed3f3e
--- /dev/null
+++ b/Software/Stubs Collection/Procedures/Priming1.txt
@@ -0,0 +1,1015 @@
+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
+
+}
+    
+}
\ No newline at end of file