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_Stapele_Span_UNDER_TEST=47;
const 	Int32	MGNET_OPEN=0x420301;
const	Int32	MGNET_EN=0x420280;
const	Int32	MGNET_CLOSE=0x420300;
const	Int32	MGNET_DIS=0x420200;
const	Int32	ACTDIR_ON=0x460280;
const	Int32	ACTDIR_OFF=0x460200;

const	Int32	ACTIN_ON=0x460308;
const	Int32	ACTOUT_ON=0x460304;

const	Int32	ACTIN_OFF=0x46030C;
const	Int32	ACTOUT_OFF=0x46030C;



const	Int32	LS_FRONT=0X460110;
const	Int32	LS_REAR=0X460120;
const	Int32	LS_UPPER=0X460140;
const	Int32	LS_SPARE=0X460180;
const	Int32	ACTIN_EN=0X460101;
const	Int32	ACTOUT_EN=0X460102;



string EEPROM_Header="Header_1         ";	//16 characters

int Head_Mux_Channel_ID = 4; //Head MUX channel


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

string [,] Units_status_New_Stapele_Span = new string[New_Stapele_Span_UNDER_TEST,2]	{ 
												{"Pt100_HTIN","Pass"},		//0
												{"Pt100_HTOUT","Pass"},		//1
												
												{"Current_HTIN1","Pass"},		//2
												{"Current_HTIN2","Pass"},		//3
												{"Current_HTIN3","Pass"},		//4
												{"Current_HTIN4","Pass"},		//5
												{"Current_HTOUT1","Pass"},		//6
												{"Current_HTOUT2","Pass"},		//7
												{"Current_HTOUT3","Pass"},		//8
												{"Current_HTOUT4","Pass"},		//9
												
												{"Break_HTIN1","Pass"},			//10
												{"Break_HTIN2","Pass"}, 		//11
												{"Break_HTIN3","Pass"}, 		//12
												{"Break_HTIN4","Pass"}, 		//13
												{"Break_HTOUT1","Pass"}, 		//14
												{"Break_HTOUT2","Pass"}, 		//15
												{"Break_HTOUT3","Pass"},		//16
												{"Break_HTOUT4","Pass"},		//17

												{"Fan_in","Not Test"},		//18
												{"Fan_out","Not Test"},		//19
												                        
																		
																		
												{"Magnet      ","Not Test"},	//18
												{"LS_REAR","Not Test"},     	//19
												{"LS_FRONT","Not Test"},    	//2
												{"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
												
												
											};



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

public Task<decimal> NewStapele_Span_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_Stapele_Span_UNDER_TEST,Units_status_New_Stapele_Span);

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

//------------------------------- start test -----------
	settext("Test Magnet Motor LS");
	Test_Magnet_Motor_LS_New_Stapele_Span();
	settext("Test blowers &pt100");
	Test_blowers_pt100 ();
	settext("Test Head EEPROM");
	Test_Head_EEPROM(SN);	
	settext("Test Actuator In");
	Test_Actuator_in();
	settext("Test Actuator Out");
	Test_Actuator_out();
	Status=write_to_file(SN,Location,Stapele_Span_UNDER_TEST,"Stapele_Span");

	settext("End Test");
	}
	decimal result = 0;
		
        return result;
    });
    return task;
}
  
//------------------------------------------------------------- 
 int Test_Actuator_in()
{  
	Int32 temp;
	int i=0;
	
	DialogResult result = MessageBox.Show("Make shure, ACTUATOR-IN is down", "Warning",MessageBoxButtons.OKCancel);
	if(result == DialogResult.Cancel)
		{
			Units_status[41,1]="Fail";
			stubManager.Write("ACTUATOR-IN is Up\n"); 
			return 0;
		}
//---------------------- move ACTUATOR-IN Up ---------------------------- 
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTDIR_ON);	// DIR=1
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTIN_ON);	// act_in enable
	delay(10);																					
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTIN_OFF);	// act_in disable
	stubManager.Write("ACTUATOR-IN  moving Up\n"); 

	temp = 1;
	 i=0;		
	while ((temp != 0x0)&& (i<200) )		//wait until Limit Switch or timeout 200*50msec=10sec
			{	
					temp=read_pio (ACTIN_EN);	// read ACTIN_EN
					delay(50);
					i++;
			}

	if(i == 200)
		{
			Units_status[41,1]="Fail";
			stubManager.Write("CTUATOR-IN is not moving Up\n");
			return 0;
		}
		
	DialogResult result2 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.OKCancel);
	if(result2 == DialogResult.Cancel)
		{
			Units_status[42,1]="Fail";
			stubManager.Write("LS_IN_UP Not calibrate\n");
			return 0;
		}
	Units_status[41,1]="Pass";
	Units_status[42,1]="Pass";
//---------------------- move ACTUATOR-IN Dn ---------------------------- 
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTDIR_OFF);	// DIR=0
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTIN_ON);	// act_in enable
	delay(10);																					
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTIN_OFF);	// act_in disable
	stubManager.Write("ACTUATOR-IN  moving Dn\n"); 

	temp = 1;
	 i=0;		
	while ((temp != 0x0)&& (i<200) )		//wait until Limit Switch or timeout 200*50msec=10sec
			{	
					temp=read_pio (ACTIN_EN);	// read ACTIN_EN
					delay(50);
					i++;
			}

	if(i == 200)
		{
			Units_status[41,1]="Fail";
			stubManager.Write("CTUATOR-IN is not moving Down\n");
			return 0;
		}
		
	DialogResult result3 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.OKCancel);
	if(result3 == DialogResult.Cancel)
		{
			Units_status[43,1]="Fail";
			stubManager.Write("LS_IN_Down Not calibrate\n");
			return 0;
		}
	Units_status[43,1]="Pass";
	return 0;

}
//------------------------------------------------------------- 
 int Test_Actuator_out()
{  
	Int32 temp;
	int i=0;
	
	DialogResult result = MessageBox.Show("Make shure, ACTUATOR-OUT is down", "Warning",MessageBoxButtons.OKCancel);
	if(result == DialogResult.Cancel)
		{
			Units_status[44,1]="Fail";
			stubManager.Write("ACTUATOR-OUT is Up\n"); 
			return 0;
		}
//---------------------- move ACTUATOR-OUT Up ---------------------------- 
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTDIR_ON);	// DIR=1
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTOUT_ON);	// act_OUT enable
	delay(10);																					
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTOUT_OFF);	// act_OUT disable
	stubManager.Write("ACTUATOR-OUT  moving Up\n"); 

	temp = 1;
	 i=0;		
	while ((temp != 0x0)&& (i<200) )		//wait until Limit Switch or timeout 200*50msec=10sec
			{	
					temp=read_pio (ACTOUT_EN);	// read ACTOUT_EN
					delay(50);
					i++;
			}

	if(i == 200)
		{
			Units_status[44,1]="Fail";
			stubManager.Write("CTUATOR-OUT is not moving Up\n");
			return 0;
		}
		
	DialogResult result2 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.OKCancel);
	if(result2 == DialogResult.Cancel)
		{
			Units_status[45,1]="Fail";
			stubManager.Write("LS_OUT_UP Not calibrate\n");
			return 0;
		}
	Units_status[44,1]="Pass";
	Units_status[45,1]="Pass";
//---------------------- move ACTUATOR-OUT Dn ---------------------------- 
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTDIR_OFF);	// DIR=0
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTOUT_ON);	// act_out enable
	delay(10);																					
	stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,ACTOUT_OFF);	// act_out disable
	stubManager.Write("ACTUATOR-OUT  moving Dn\n"); 

	temp = 1;
	 i=0;		
	while ((temp != 0x0)&& (i<200) )		//wait until Limit Switch or timeout 200*50msec=10sec
			{	
					temp=read_pio (ACTOUT_EN);	// read ACTOUT_EN
					delay(50);
					i++;
			}

	if(i == 200)
		{
			Units_status[44,1]="Fail";
			stubManager.Write("CTUATOR-OUT is not moving Down\n");
			return 0;
		}
		
	DialogResult result3 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.OKCancel);
	if(result3 == DialogResult.Cancel)
		{
			Units_status[46,1]="Fail";
			stubManager.Write("LS_OUT_Down Not calibrate\n");
			return 0;
		}
	Units_status[46,1]="Pass";
	return 0;

}



//-------------------------------------------- 
 int Test_Magnet_Motor_LS_New_Stapele_Span()
{  
	Int32 temp;
	int i=0;
//---------------------- open Magnet ---------------------------- 
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,MGNET_OPEN);	// turn magnet on
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,MGNET_EN);	// magnet enable
		stubManager.Write("Magnet is Open\n"); 
		delay(1000);																					
//---------------------- chekc Magnet is open  ---------------------------- 
		temp=read_pio (LS_UPPER);	// read LS_UPPER
		if (temp != 0)		
		{	
			Units_status[36,1]="Fail";
			stubManager.Write("Magnet is close\n"); 
			return 0;
		}
	DialogResult result = MessageBox.Show("Make shure, Magnet is open", "Warning",MessageBoxButtons.OKCancel);
	if(result == DialogResult.Cancel)
		{
			Units_status[36,1]="Fail";
			stubManager.Write("Magnet is close\n"); 
			return 0;
		}
//---------------------- 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
	if(i == 200)
		{
			Units_status[37,1]="Fail";
			Units_status[39,1]="Fail";
			stubManager.Write("LS_REAR Not calibrate\n");
			return 0;
		}
	DialogResult result2 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.OKCancel);
	if(result2 == DialogResult.Cancel)
		{
			Units_status[37,1]="Fail";
			Units_status[39,1]="Fail";
			stubManager.Write("LS_REAR Not calibrate\n");
			return 0;
		}
	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
	if(i == 200)
		{
			Units_status[38,1]="Fail";
			stubManager.Write("LS_FRONT Not calibrate\n");
			return 0;
		}
		
	DialogResult result3 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.OKCancel);
	if(result3 == DialogResult.Cancel)
		{
			Units_status[38,1]="Fail";
			stubManager.Write("LS_FRONT Not calibrate\n");
			return 0;
		}
	Units_status[37,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  ---------------------------- 
		temp=read_pio (LS_UPPER);	// read LS_UPPER
		if (temp == 0)		
		{	
			Units_status[36,1]="Fail";
			stubManager.Write("Magnet is open\n"); 
			return 0;
		}
	DialogResult result4 = MessageBox.Show("Make shure, Magnet is close", "Warning",MessageBoxButtons.OKCancel);
	if(result4 == DialogResult.Cancel)
		{
			Units_status[36,1]="Fail";
			stubManager.Write("Magnet is open\n"); 
			return 0;
		}
			Units_status[36,1]="Pass";
			stubManager.Write("Magnet is close\n"); 
			return 0;
}		
  

//------------------------------------  
public int Test_blowers_pt100_fan()
{
	
//	uint utemp=0;
	Int32 temp=0;
	float ftemp=0;
	float ftemp1=0;
	float current=0;
	Double current_sense; 

	for (Int32 i = 0; i < 2; i++)
	{
	//---------------------- check fans---------------------------- 
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfac0+i, 0xff);//Fan Click Head Card , Fan 1 Setting - 0xFF Full PWM 0x80 = 50%  FF = 100% 0 - STOP
		delay(2000);																					//delay 2 second

		var response5 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfac0+i, 0xff);//Fan Click Head Card , Fan 1 Setting - 0xFF Full PWM 0x80 = 50%  FF = 100% 0 - STOP
		temp = (Int32) (response.Progress);
		temp =temp & (response.Progress & 0xffff);						//
		if (temp>0xEC0)
		{
			Units_status[18+i,1]="Fail";
			return 0;
		}
			Units_status[18+i,1]="Pass";
		
		//---------------------- get tempurature of heaters---------------------------- 
		if	(i==0)
			temp=18;
		else
			temp=16;
		var response = stubManager.Run<StubTempSensorResponse>("StubTempSensorRequest" , 0x8000 +temp);	//get temperature from the buffer
		 ftemp = (float)response.TemperatureCMultBy100;
		ftemp = ftemp / 100;

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

		}
		stubManager.Write("Hit-"+(i+1)+ "\t" + ftemp.ToString("F2")+"°C\n"); 

		for (Int32 j = 0; j < 4; j++)
		{
			Int32 tdly=10000;
		//---------------------- get current of heaters  ---------------------------- 
		var response1 = stubManager.Run<StubMidTankPressureSensorResponse>("StubMidTankPressureSensorRequest" ,0x8000 +12 + 4*i +j); // get current
			current_sense=2*response1.Pressure;
			if (current_sense>0.1)
			{	
				Units_status[2+j+4*i,1]="Fail";
			}
			stubManager.Write("current is "+(j+1+4*i )+ "\t" + current_sense +"\n"); 
		//---------------------- get Break of heaters  ---------------------------- 
		var response2 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x440000 +0x20000*i +(1-i)*0x100);	// read break
			temp = (Int32) (response2.Progress);
			if ((temp & (1<<((1-i)*4+j))) !=0)						//if break ok
			{	
				Units_status[10+j+4*i,1]="Fail";
				stubManager.Write("Break Zone "+(i*4+j+1)+ "\t is Off\n"); 
			}
			else
			{
				stubManager.Write("Break Zone "+(i*4+j+1)+ "\t is On\n"); 
			}
		//---------------------- turn heater on  ---------------------------- 
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x400300 +0x1fff00*i  +(1<<((1-i)*4+j)));	// turn heater on 
			stubManager.Write("Heater -  "+(i*4+j+1)+ "\t is On\n"); 
			delay(2000);																					//delay 2 second
		//---------------------- get current of heaters  ---------------------------- 
		var response3 = stubManager.Run<StubMidTankPressureSensorResponse>("StubMidTankPressureSensorRequest" ,0x8000 + +12 + 4*i +j); // get current
			current_sense=2*response3.Pressure;
			if ((current_sense<1.1) ||(current_sense>1.4) )		//if current not 2.5A  
			{	
				Units_status[2+j+4*i,1]="Fail";
			}
			stubManager.Write("current is "+(j+1+4*i )+"\t" + current_sense +"\n"); 
		//---------------------- get Break of heaters  ---------------------------- 
		var response4 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x440000 +0x20000*i +(1-i)*0x100);	// read break
			temp = (Int32) (response4.Progress);
			if ((temp & (1<<((1-i)*4+j))) !=0)						//if break ok
			{	
				Units_status[10+j+4*i,1]="Fail";
				stubManager.Write("Break Zone "+(i*4+j+1)+ "\t is Off\n"); 
			}
			else
			{
				stubManager.Write("Break Zone "+(i*4+j+1)+ "\t is On\n"); 
			}
	
			delay(tdly); //delay 20 second
		//---------------------- turn heater off  ---------------------------- 
			
			stubManager.Run<ProgressResponse>("ProgressRequest" ,0x0EAD,0x400300 +0x1fff00*i );	// turn heater on 
			stubManager.Write("Heater -  "+(i*4+j+1)+ "\t is Off\n"); 
		}
		//---------------------- get tempurature of heaters---------------------------- 
		if	(i==0)
			temp=18;
		else
			temp=16;
		var response = stubManager.Run<StubTempSensorResponse>("StubTempSensorRequest" , 0x8000 +temp);	//get temperature from the buffer
		 ftemp1 = (float)response.TemperatureCMultBy100;
		ftemp1 = ftemp1 / 100;

		if (((ftemp1-ftemp)<5)|| ((ftemp1-ftemp)>35))
		{	
			Units_status[i,1]="Fail";
		}
		stubManager.Write("Zone-"+(i+1)+ "after heating is \t" + ftemp1.ToString("F2")+"°C\n"); 

	//---------------------- check fan off---------------------------- 
		
		stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfac0+i, 0);//Fan Click Head Card , Fan 1 Setting - 0xFF Full PWM 0x80 = 50%  FF = 100% 0 - STOP
		delay(2000);																					//delay 2 second
		var response6 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0xfac0+i, 0);//Fan Click Head Card , Fan 1 Setting - 0xFF Full PWM 0x80 = 50%  FF = 100% 0 - STOP
		temp = (Int32) (response6.Progress);
		temp =temp & (response.Progress & 0xffff);						//
		if (temp<0x0xFF00)
		{
			Units_status[18+i,1]="Fail";
			return 0;
		}
		
	}	
			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(20); 					//Sleep for 5 milli. - must! otherwise read 0xff (See data sheet )	
		
		adc_set_for_read_ch(0xA0);
		//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
	//--------------------------------------------------------------
		char[] characters = EEPROM_Header.ToCharArray();	

	for (int i=0;i<16;i++)
		{
		stubI2CWriteBytesRequest.BytesTWrite.Add(characters[i]);	//add header
		}
		characters = s_n.ToCharArray();	
		
	for (int i=0;i<16;i++)
		{
			stubI2CWriteBytesRequest.BytesTWrite.Add(characters[i]);	//add s/n
		}
	var response = stubManager.Run<StubI2CWriteBytesResponse>(stubI2CWriteBytesRequest);
	
	return 1;
}

int Read_EEPROM(uint I2C_Slave_Add) 
{
	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++)
	{
			if (characters[i]!=response1.ReadBytes[i]);
				Units_status[40,1]="Fail";
	}
	stubManager.Write("EEprom "+ Units_status[40,1]+"\n"); 
	
	return 1;
}