path: root/Software/Stubs Collection/stubs/Scripts/Jig_Tester/New_DyeHead_Jig.cs

using System;
using System.Text;
using System.IO;
using System.Linq;
using System.Drawing;
using System.Diagnostics;
using System.Windows.Forms;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Tango.PMR.Stubs;
using Tango.Stubs;

const	int 	New_DyeHead_UNDER_TEST=48;

const 	Int32	MGNET_OPEN=0x42F801;
const	Int32	MGNET_EN=0x42F701;
const	Int32	MGNET_CLOSE=0x42F800;
const	Int32	MGNET_DIS=0x42F700;

const	Int32	LS_FRONT=0X460110;
const	Int32	LS_REAR=0X460120;
const	Int32	LS_UPPER=0X460140;
const	Int32	LS_SPARE=0X460180;


string EEPROM_Header="Header_1         ";	//16 characters

int Head_Mux_Channel_ID = 4; //Head MUX channel
		char[] characters = new char[16];	


//float [] DyeHeadTemp = new float[6]	;

string [,] Units_status_New_DyeHead = new string[New_DyeHead_UNDER_TEST,2]	{ 
												{"Pt100_Zone_1","Pass"},		//0
												{"Pt100_Zone_2","Pass"},		//1
												{"Pt100_Zone_3","Pass"},		//2
												{"Pt100_Zone_4","Pass"},		//3
												{"Pt100_Zone_5","Pass"},		//4
												{"Pt100_Zone_6","Pass"},		//5
												{"Pt100_Zone_7","Pass"},		//6
												{"Pt100_Zone_8","Pass"},		//7
												{"Pt100_Zone_9","Pass"},		//8
												{"Pt100_Zone_10","Pass"},		//9
												{"Pt100_Zone_11","Pass"},		//10
												{"Pt100_Zone_12","Pass"},		//11
												
												{"Current_Zone_1","Pass"},		//12
												{"Current_Zone_2","Pass"},		//13
												{"Current_Zone_3","Pass"},		//14
												{"Current_Zone_4","Pass"},		//15
												{"Current_Zone_5","Pass"},		//16
												{"Current_Zone_6","Pass"},		//17
												{"Current_Zone_7","Pass"},		//18
												{"Current_Zone_8","Pass"},		//19
												{"Current_Zone_9","Pass"},		//20
												{"Current_Zone_10","Pass"},		//21
												{"Current_Zone_11","Pass"},		//22
												{"Current_Zone_12","Pass"},		//23
												
												{"Break_Zone_1","Pass"},		//24
												{"Break_Zone_2","Pass"}, 		//25
												{"Break_Zone_3","Pass"}, 		//26
												{"Break_Zone_4","Pass"}, 		//27
												{"Break_Zone_5","Pass"}, 		//28
												{"Break_Zone_6","Pass"}, 		//29
												{"Break_Zone_7","Pass"},		//30
												{"Break_Zone_8","Pass"},		//31
												{"Break_Zone_9","Pass"},		//32
												{"Break_Zone_10","Pass"},		//33
												{"Break_Zone_11","Pass"},		//34
												{"Break_Zone_12","Pass"},		//35
												                        
												{"Magnet      ","Not Test"},	//36
												{"LS_REAR","Not Test"},     	//37
												{"LS_FRONT","Not Test"},    	//38
												{"DH_LID_Motor","Not Test"},	//39
												
												{"EEPROM ","Pass"},				//40
												
												{"ACTUATOR_IN","Not Test"},			//41
												{"LS_IN_UP","Not Test"},			//42
												{"LS_IN_DN","Not Test"},			//43
												{"ACTUATOR_OUT","Not Test"},		//44
												{"LS_OUT_UP","Not Test"},			//45
												{"LS_OUT_DN","Not Test"},			//46
												
												{"LS_MAGNET_DN","Not Test"},			//47
												
												
											};



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

public Task<decimal> NewDyeHead_test( Action<string> settext, CancellationToken cancellationToken, string SN, string Location)
{
    Task<decimal> task = null;
    // Start a task and return it
    task = Task.Run(() =>
    { 
	stubManager.Write("S/N:" +SN+ "\n");
	stubManager.Write("Location:" +Location+ "\n");

	copy_table (New_DyeHead_UNDER_TEST,Units_status_New_DyeHead);
	DialogResult result1 = MessageBox.Show("Make shure, Dyehead is not hot", "Warning",MessageBoxButtons.OKCancel);
	if(result1 == DialogResult.Cancel)
		{
			stubManager.AppendToFile(File_Name1,"Dyehead is too hot \tFail");
			stubManager.Write("Dyehead is too hot \tFail\n");
			return 0 ;
		}
	else
	{

//------------------------------- start test -----------
	settext("Test Magnet Motor LS");
//	stubManager.Run<ProgressResponse>("ProgressRequest" ,0xC3,0);	// disable i2c
	Test_Magnet_Motor_LS_New_DyeHead();
	delay(2000);
//	stubManager.Run<ProgressResponse>("ProgressRequest" ,0xC3,1);	// enable i2c
	delay(2000);
																					
	
	settext("Test heaters &pt100");
	Test_new_heaters_pt100 ();
	settext("Test Head EEPROM");
	Test_Head_EEPROM(SN);			//pass
	settext("Test Actuator In");
	Test_Actuator_in();				//pass
	settext("Test Actuator Out");
	Test_Actuator_out();			//pass
	Status=write_to_file(SN,Location,New_DyeHead_UNDER_TEST,"Dyehead");

	settext("End Test");
	}
	decimal result = 0;
		
        return result;
    });
    return task;
}
  
//------------------------------------------------------------- 
 int Test_Actuator_in()
{  
	Int32 temp;
	int i=0;

			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf000);		//mov ACTUATOR-IN Dn
			delay(2000);																					

	
//	DialogResult result = MessageBox.Show("Is ACTUATOR-IN on Upper Limit Swtich?", "Warning",MessageBoxButtons.YesNo);
//	if(result == DialogResult.Yes)
//		{
//			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf000);		//mov ACTUATOR-IN down
//
//			delay(2000);																					
//			DialogResult result2 = MessageBox.Show("Is ACTUATOR-IN Move to Lower Limit Switch?", "Warning",MessageBoxButtons.YesNo);
//			if(result2 != DialogResult.Yes)
//				{
//					Units_status[43,1]="Fail";
//					return 0;
//				}
//			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf001);		//mov ACTUATOR-IN up
//			delay(2000);																					
//			DialogResult result3 = MessageBox.Show("Is ACTUATOR-IN Move to Upper Limit Switch?", "Warning",MessageBoxButtons.YesNo);
//			if(result3 != DialogResult.Yes)
//				{
//					Units_status[42,1]="Fail";
//					return 0;
//				}
//			Units_status[41,1]="Pass";
//			Units_status[42,1]="Pass";
//			Units_status[43,1]="Pass";
//			return 0;
//		}
//		else
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf001);		//mov ACTUATOR-IN up
			delay(2000);																					
			DialogResult result4 = MessageBox.Show("Is ACTUATOR-IN Move to Upper Limit Switch ?", "Warning",MessageBoxButtons.YesNo);
			if(result4 != DialogResult.Yes)
				{
					Units_status[42,1]="Fail";
					return 0;
				}
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf000);		//mov ACTUATOR-IN down
			delay(2000);																					
			DialogResult result6 = MessageBox.Show("Is ACTUATOR-IN Move to Lower Limit Switch?", "Warning",MessageBoxButtons.YesNo);
			if(result6 != DialogResult.Yes)
				{
					Units_status[43,1]="Fail";
					return 0;
				}
			Units_status[41,1]="Pass";
			Units_status[42,1]="Pass";
			Units_status[43,1]="Pass";
			return 0;
}



//------------------------------------------------------------- 
 int Test_Actuator_out()
{  
	Int32 temp;
	int i=0;
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf100);		//mov ACTUATOR-OUT down
			delay(2000);																					
	
//	DialogResult result = MessageBox.Show("Is ACTUATOR-OUT on Upper Limit swtich?", "Warning",MessageBoxButtons.YesNo);
//	if(result == DialogResult.Yes)
//		{
//			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf100);
//
//
//			delay(2000);																					
//			DialogResult result1 = MessageBox.Show("Is ACTUATOR-OUT Move to Lower Limit Switch?", "Warning",MessageBoxButtons.YesNo);
//			if(result1 != DialogResult.Yes)
//				{
//					Units_status[46,1]="Fail";
//					return 0;
//				}
//
//			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf101);		//mov ACTUATOR-OUT up
//			delay(2000);																					
//			DialogResult result3 = MessageBox.Show("Is ACTUATOR-OUT Move to Upper Limit Switch?", "Warning",MessageBoxButtons.YesNo);
//			if(result3 != DialogResult.Yes)
//				{
//					Units_status[45,1]="Fail";
//					return 0;
//				}
//			Units_status[44,1]="Pass";
//			Units_status[45,1]="Pass";
//			Units_status[46,1]="Pass";
//			return 0;
//		}
//		else
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf101);		//mov ACTUATOR-OUT up
			delay(2000);																					
			DialogResult result4 = MessageBox.Show("Is ACTUATOR-OUT Move to Upper Limit Switch?", "Warning",MessageBoxButtons.YesNo);
			if(result4 != DialogResult.Yes)
				{
					Units_status[45,1]="Fail";
					return 0;
				}
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfead, 0xcaf100);		//mov ACTUATOR-OUT down
			delay(2000);																					
			DialogResult result6 = MessageBox.Show("Is ACTUATOR-OUT Move to Lower Limit Switch?", "Warning",MessageBoxButtons.YesNo);
			if(result6 != DialogResult.Yes)
				{
					Units_status[46,1]="Fail";
					return 0;
				}
			Units_status[44,1]="Pass";
			Units_status[45,1]="Pass";
			Units_status[46,1]="Pass";
			return 0;
		}


//-------------------------------------------- 
 int Test_Magnet_Motor_LS_New_DyeHead()
{  
	Int32 temp;
	int i=0;
	
//---------------------- open Magnet ---------------------------- 
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,MGNET_OPEN);	// turn magnet on
					delay(100);

		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,MGNET_EN);	// magnet enable
							delay(100);

		stubManager.Write("Magnet is Open\n"); 
		delay(1000);																					
//---------------------- chekc Magnet is open  ---------------------------- 
	DialogResult result = MessageBox.Show("Make shure, Magnet is open and DyeHead cover on front.", "Warning",MessageBoxButtons.YesNo);
	if(result == DialogResult.No)
		{
			Units_status[36,1]="Fail";
			stubManager.Write("Magnet is close\n"); 
			return 0;
		}
		temp=read_pio (LS_UPPER);	// read LS_UPPER
		if (temp != 0)		
		{	
			Units_status[47,1]="Fail";
			stubManager.Write("LS_UPPER of Magnet is close\n"); 
		}
		
		
//---------------------- Move DyeingHead Lid Motor rear---------------------------- 
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,DyeingHeadLid_Motor, true, 250);
	stubManager.Write("***   Open Lid Head ********* \n");
	
	temp = 0;
	 i=0;		
	while ((temp == 0x0)&& (i<200) )		//wait until Limit Switch or timeout 200*50msec=10sec
			{	
					temp=read_pio (LS_REAR);	// read LS_REAR
					delay(50);

					i++;
			}
			
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,DyeingHeadLid_Motor,3);		//stop motor
	DialogResult result2 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	if(result2 == DialogResult.No || i==200)
		{
			Units_status[37,1]="Fail";
			stubManager.Write("LS_REAR Not calibrate\n");
		}
		else
			Units_status[37,1]="Pass";
//---------------------- Move DyeingHead Lid Motor front---------------------------- 
	stubManager.Write("***   Close Lid Head \n");
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,DyeingHeadLid_Motor, false, 250);
	temp = 0;
	 i=0;		
	while ((temp == 0x0)&& (i<200) )		//wait until Limit Switch or timeout 200*50msec=10sec
			{	
					temp=read_pio (LS_FRONT);	// read LS_FRONT
					delay(50);
					i++;
			}
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,DyeingHeadLid_Motor,3);		//stop motor
		
	DialogResult result3 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	if(result3 == DialogResult.No || i==200)
		{
			Units_status[38,1]="Fail";
			stubManager.Write("LS_FRONT Not calibrate\n");
		}
		else
		{
			Units_status[39,1]="Pass";
			Units_status[38,1]="Pass";
		}
//---------------------- Close Magnet ---------------------------- 
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,MGNET_CLOSE);	// turn magnet off
		delay(2000);																					
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,MGNET_DIS);	// magnet Disable
		
		stubManager.Write("Magnet is Close\n"); 
		delay(1000);																					
//---------------------- chekc Magnet is close  ---------------------------- 

	DialogResult result4 = MessageBox.Show("Make shure, Magnet is close", "Warning",MessageBoxButtons.YesNo);
	if(result4 == DialogResult.No)
	{
			Units_status[36,1]="Fail";
			stubManager.Write("Magnet is open\n"); 
				return 0;
	}
		Units_status[36,1]="Pass";
		temp=read_pio (LS_UPPER);	// read LS_UPPER
		if (temp == 0)		
		{	
			Units_status[47,1]="Fail";
			stubManager.Write("LS_UPPER of Magnet is open\n"); 
			return 0;
		}
			Units_status[47,1]="Pass";
			stubManager.Write("LS_UPPER of Magnet is close\n"); 
			return 0;
	}
//------------------------------------  
public int Test_new_heaters_pt100()
{
	
//	uint utemp=0;
	Int32 temp=0;
	float ftemp=0;
	float ftemp1=0;
	float current=0;
	Double current_sense; 

	for (Int32 i = 0; i < 12; i++)					//12
	{
		Int32 tdly=20000;
//---------------------- get tempurature of heaters---------------------------- 
		temp= 12+i/2+(i%2)*8;			//HZone_1=12
										//HZone_2=20
										//HZone_3=13
										//HZone_4=21
										//HZone_5=14
										//HZone_6=22
										//HZone_7=15
										//HZone_8=23
										//HZone_9=16
										//HZone_10=24
										//HZone_11=17
										//HZone_11=25
										
		var response = stubManager.Run<StubTempSensorResponse>("StubTempSensorRequest" , temp);	//get temperature from the buffer
		 ftemp = (float)response.TemperatureCMultBy100;
		ftemp = ftemp / 100;

		if ((ftemp>50)|| (ftemp<15))
		{	
			Units_status[i,1]="Fail";
			tdly=2000;

		}
		stubManager.Write("Zone-"+(i+1)+ "-\t" + ftemp.ToString("F2")+"°C\n"); 
//---------------------- get current of heaters  ---------------------------- 
	var response1 = stubManager.Run<StubMidTankPressureSensorResponse>("StubMidTankPressureSensorRequest" ,0x8000 + i); // get current
		current_sense=response1.Pressure;
		if (current_sense>0.1)
		{	
			Units_status[i+12,1]="Fail";
		}
		stubManager.Write("current zone -" +(i+1)+ " is \t-" + current_sense +"\n"); 
//---------------------- get Break of heaters  ---------------------------- 
	var response2 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x440000 +(i/8)*0x100+(1<<(i&7)));	// read break
		temp = (Int32) (response2.Progress);
		if ((temp & (1<<(i&7))) ==0)						//if break ok
		{	
			Units_status[i+24,1]="Fail";
			stubManager.Write("Break Zone "+(i+1)+ "\t is on\n"); 
		}
		else
		{
			stubManager.Write("Break Zone "+(i+1)+ "\t is Off\n"); 
		}
//---------------------- turn heater on  ---------------------------- 
//		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x400200 +(i/8)*0x100+(1<<(i&7)));	// turn heater on 
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x40F001 + i*0x100);				// turn heater on 

		stubManager.Write("Heater- "+(i+1)+ "\t is On\n"); 
		delay(tdly);																					//delay 10 second
//---------------------- get current of heaters  ---------------------------- 
	var response3 = stubManager.Run<StubMidTankPressureSensorResponse>("StubMidTankPressureSensorRequest" ,0x8000 + i); // get current
		current_sense=response3.Pressure;
		if ((current_sense<1.0) ||(current_sense>1.5) )		//if current not 1.25A  
		{	
			Units_status[i+12,1]="Fail";
		}
		stubManager.Write("current zone -" +(i+1)+ " is \t-" + current_sense +"\n"); 
//---------------------- get Break of heaters  ---------------------------- 
	var response4 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x440000 +(i/8)*0x100+(1<<(i&7)));	// read break
		temp = (Int32) (response4.Progress);
		if ((temp & (1<<(i&7))) ==0)						//if break ok
		{
			stubManager.Write("Break Zone "+(i+1)+ "\t is On\n"); 
			Units_status[i+24,1]="Fail";
		}
		else
		{
			stubManager.Write("Break Zone "+(i+1)+ "\t is Off\n"); 

		}
		temp= 12+i/2+(i%2)*8;
		var response5 = stubManager.Run<StubTempSensorResponse>("StubTempSensorRequest" , temp);	//get temperature from the buffer
		ftemp1 = (float)response5.TemperatureCMultBy100;
		ftemp1 = ftemp1 / 100;

		if (((ftemp1-ftemp)<10)|| ((ftemp1-ftemp)>45))
		{	
			Units_status[i,1]="Fail";
		}
		stubManager.Write("Zone-"+(i+1)+ " after heating is \t" + ftemp1.ToString("F2")+"°C\n"); 
//---------------------- turn heater off  ---------------------------- 
//		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x400200 +(i/8)*0x100);	// turn heater off 
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x40F000 + i*0x100);				// turn heater OFF 

		stubManager.Write("Heater -  "+(i+1)+ "\t is Off\n"); 

	}	
			return 0;
}

Int32 read_pio(Int32 i2c_input)
{
		Int32 temp=0;
	var response = stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,i2c_input);	// read break

		temp = (Int32) (response.Progress);
		temp =temp & (i2c_input& 0xff);						//if break ok

		return temp;
}
//end mati
	
	//enable_all_channel();
public int Test_Head_EEPROM(string s_n)
{

	enable_channel(Head_Mux_Channel_ID); // Chanel 0-7 => Disp0enser 0-7 
	
		Write_EEPROM(0xA0,s_n);
		delay(200); 					//Sleep for 5 milli. - must! otherwise read 0xff (See data sheet )	
		
//------------ go to address 0 on eeprom --------------
	StubI2CWriteBytesRequest stubI2CWriteBytesRequest = new StubI2CWriteBytesRequest();
	stubI2CWriteBytesRequest.I2CId = I2C_ID3;
	stubI2CWriteBytesRequest.SlaveAddress = 0xA0;
	
	UInt32 uInt32 = new UInt32();
	stubI2CWriteBytesRequest.BytesTWrite.Add(0);//Byte 0 to write
	stubI2CWriteBytesRequest.BytesTWrite.Add(0);//Byte 0 to write
	stubManager.Run<StubI2CWriteBytesResponse>(stubI2CWriteBytesRequest);
		
		//Thread.Sleep(1); //Sleep for 10 milli.
		Read_EEPROM(0xA0);
		
		delay(20); 					//Sleep for 5 milli. - must! otherwise read 0xff (See data sheet )	
		return 0;

}

int enable_channel(int Channel_ID) 
{
	uint Const_temp = 0x01;	
	
	StubI2CWriteBytesRequest stubI2CWriteBytesRequest = new StubI2CWriteBytesRequest();
	stubI2CWriteBytesRequest.I2CId = I2C_ID3;
	stubI2CWriteBytesRequest.SlaveAddress = TCA9548A_address;
	
	Const_temp = Const_temp << Channel_ID;
	stubI2CWriteBytesRequest.BytesTWrite.Add(Const_temp);

	var response = stubManager.Run<StubI2CWriteBytesResponse>(stubI2CWriteBytesRequest);
	
	return 1;
}

int Write_EEPROM (uint I2C_Slave_Add,string s_n   ) 
{

	StubI2CWriteBytesRequest stubI2CWriteBytesRequest = new StubI2CWriteBytesRequest();
	stubI2CWriteBytesRequest.I2CId = I2C_ID3;
	stubI2CWriteBytesRequest.SlaveAddress = I2C_Slave_Add;
	
	UInt32 uInt32 = new UInt32();
	stubI2CWriteBytesRequest.BytesTWrite.Add(0);//Byte 0 to write
	stubI2CWriteBytesRequest.BytesTWrite.Add(0);//Byte 0 to write
	
	//--------------------------------------------------------------
		characters = EEPROM_Header.ToCharArray();	

	for (int i=0;i<16;i++)
		{
		stubI2CWriteBytesRequest.BytesTWrite.Add(characters[i]);	//add header
	//		characters[i]=0x20;
		}
		characters = s_n.ToCharArray();	
		
	for (int i=0;i<characters.Length ;i++)
		{
			
			stubI2CWriteBytesRequest.BytesTWrite.Add(characters[i]);	//add s/n

		}
	var response = stubManager.Run<StubI2CWriteBytesResponse>(stubI2CWriteBytesRequest);
	
	return 1;
}

int Read_EEPROM(uint I2C_Slave_Add) 
{
		char temp;
	StubI2CReadBytesRequest stubI2CReadBytesRequest = new StubI2CReadBytesRequest();
	stubI2CReadBytesRequest.I2CId = I2C_ID3;
	stubI2CReadBytesRequest.SlaveAddress = I2C_Slave_Add + 1;
	stubI2CReadBytesRequest.NumberOfBytesToRead = 16; // Number of header bytes to read

	var response1 = stubManager.Run<StubI2CReadBytesResponse>(stubI2CReadBytesRequest);
	uint temph=0;
		char[] characters = EEPROM_Header.ToCharArray();	
	for(int i=0; i<stubI2CReadBytesRequest.NumberOfBytesToRead;i++)
	{
			temp =  Convert.ToChar(response1.ReadBytes[i]);


	}
	
	return 1;
}