output.i

电表解决方案概要power_meter_r8c2g_source_code

 

 

extern const unsigned char Memo_Soak_Time_Table[3][3];				 

extern const unsigned char Memo_Wash_Time_Table[3][3];				 

extern const unsigned char Standard_Soak_Time_Table[3][3];			 

extern const unsigned char Standard_Wash_Time_Table[3][3];			 

extern const unsigned char Strong_Soak_Time_Table[3];				 

extern const unsigned char Strong_Wash_Time_Table[3];				 


extern const unsigned char Soft_Soak_Time;					 
extern const unsigned char Soft_Wash_Time;					 

extern const unsigned char Child_Soak_Time;					 
extern const unsigned char Child_Wash_Time;					 

extern const unsigned char Wool_Soak_Time;					 

extern const unsigned char Wool_Wash_Time;					 

extern const unsigned char Silk_Wash_Time;					 
extern const unsigned char Speedy_Wash_Time;				 

extern const unsigned char seg_led_table[];					 

extern const unsigned char OPT_Table[];						 

extern const unsigned char Left_time_Colum_Table[];			 



#line 5 "D:/Projects/Haier/General Washer/workspace/General_Washer/General_Washer/src/output.c"

#line 1 "D:/Projects/Haier/General Washer/workspace/General_Washer/General_Washer/src/Iic.h"
 















typedef unsigned char uchar;

 
typedef struct {            
	
	unsigned char iic_DeviceAddress;
	unsigned char iic_MemoryAddress;
	unsigned char *iic_Data;
	unsigned char iic_NumberOfByte;

}IicPack;

void initIicBus(void);							 

unsigned char IicBusRead(IicPack *);			 
unsigned char IicBusWrite(IicPack *);			 

void StartCondition(void);			 
void StopCondition(void);			 

unsigned char ByteWrite(unsigned char);					 
void ByteRead (unsigned char *, unsigned char);			 
#line 6 "D:/Projects/Haier/General Washer/workspace/General_Washer/General_Washer/src/output.c"


 

 



void water_detect(void);				 
void wash_detect(void);					 
void ac_freqcy_detect(void);			 
void lid_detect(void);					 
void unbalance_detect(void);			 
                 
 





void alarm(void)
{
 if (err_buff)
  {
	  process_flag_2.f_bit.fb5		 		 = 1;	  
	  	 	  
	  switch (err_buff)
	  {
		  case 0x01		    :				 
		  
		  if (lid_open == 0)
		   {
			  save_water_flag_1.f_bit.fb4		  = 0;			   
		  	  err_buff = 0;		 
		  	  status_buff = 0x02				  ;
			  
		  	  display_flag_1.f_bit.fb6	  = 1;
		  	  display_flag_1.f_bit.fb7	  = 0;	
			  		  
			  buzz_flag_1.f_bit.fb1		 	 = 0;
			  process_flag_2.f_bit.fb5		 		 = 0;
			  
	    	  Pflash = 0;
	    	  Tflash = 0;						
	    	  Pflash_switch_flag = 0x00;	
	    	  display_flag_1.f_bit.fb0	  = 0;			  			  
		   }
		  break;
		  
		  
		  case 0x02		    :					 
		  
		  if (save_water_flag_1.f_bit.fb4		  == 1)
		   {
			  save_water_flag_1.f_bit.fb4		  = 0;
		  	  err_buff = 0;		 
		  	  status_buff = 0x02				  ;
		  	  display_flag_1.f_bit.fb6	  = 1;
		  	  display_flag_1.f_bit.fb7	  = 0;			  
			  buzz_flag_1.f_bit.fb1		 	 = 0;	
			  process_flag_2.f_bit.fb5		 		 = 0;		
			  
	    	  Pflash = 0;
	    	  Tflash = 0;						
	    	  Pflash_switch_flag = 0x00;
	    	  display_flag_1.f_bit.fb0	  = 0;					  				  	  		  
		   }			  		  
		  break;
		  
		  
		  case 0x03		    :				 
		  
		  if (lid_open == 0)
		   {
			  save_water_flag_1.f_bit.fb4		  = 0;			   
		  	  err_buff = 0;		 
		  	  status_buff = 0x02				  ;
		  	  display_flag_1.f_bit.fb6	  = 1;
		  	  display_flag_1.f_bit.fb7	  = 0;			  
			  buzz_flag_1.f_bit.fb1		 	 = 0;	
			  process_flag_2.f_bit.fb5		 		 = 0;		
			  
	    	  Pflash = 0;
	    	  Tflash = 0;						
	    	  Pflash_switch_flag = 0x00;	
	    	  display_flag_1.f_bit.fb0	  = 0;					  			  	  		  
		   }		  		  
		  break;
		  
		  
		  case 0x04		    :			 
		  
		  if (save_water_flag_1.f_bit.fb4		  == 1)
		   {
			  save_water_flag_1.f_bit.fb4		  = 0;
		  	  err_buff = 0;		 
		  	  status_buff = 0x02				  ;
		  	  display_flag_1.f_bit.fb6	  = 1;
		  	  display_flag_1.f_bit.fb7	  = 0;			  
			  buzz_flag_1.f_bit.fb1		 	 = 0;	
			  process_flag_2.f_bit.fb5		 		 = 0;		
			  
	    	  Pflash = 0;
	    	  Tflash = 0;						
	    	  Pflash_switch_flag = 0x00;	
	    	  display_flag_1.f_bit.fb0	  = 0;					  			  	  		  
		   }			  		  
		  break;
		  
		  
		  case 0x05		    :					 
		  
		  if (save_water_flag_1.f_bit.fb4		  == 1)
		   {
			  save_water_flag_1.f_bit.fb4		  = 0;
		  	  err_buff = 0;		 
		  	  status_buff = 0x02				  ;
		  	  display_flag_1.f_bit.fb6	  = 1;
		  	  display_flag_1.f_bit.fb7	  = 0;			  
			  buzz_flag_1.f_bit.fb1		 	 = 0;	
			  process_flag_2.f_bit.fb5		 		 = 0;	
			  
	    	  Pflash = 0;
	    	  Tflash = 0;						
	    	  Pflash_switch_flag = 0x00;	
	    	  display_flag_1.f_bit.fb0	  = 0;					  			  		  		  
		   }			  
		  break;
		  
		  
		  case 0x06		    :			 
		  
		  if (save_water_flag_1.f_bit.fb4		  == 1)
		   {
			  save_water_flag_1.f_bit.fb4		  = 0;
		  	  err_buff = 0;		 
		  	  status_buff = 0x02				  ;
		  	  display_flag_1.f_bit.fb6	  = 1;
		  	  display_flag_1.f_bit.fb7	  = 0;			  
			  buzz_flag_1.f_bit.fb1		 	 = 0;	
			  process_flag_2.f_bit.fb5		 		 = 0;			
			  
	    	  Pflash = 0;
	    	  Tflash = 0;						
	    	  Pflash_switch_flag = 0x00;	
	    	  display_flag_1.f_bit.fb0	  = 0;					  			    		  
		   }			  
		  break;		  		  		  		  		  
		  
	  };
	  
  }
 
 if (save_water_flag_1.f_bit.fb1		  == 1)	
  {
	  status_buff = 0x03				  ;
	  buzz_flag_1.f_bit.fb1		 	 = 1;				 
  }
 if (process_flag_2.f_bit.fb5		 		 == 1)
  {
	  status_buff = 0x03				  ;	  
	  buzz_flag_1.f_bit.fb1		 	 = 1;				 
  }

}

 





void input(void)
{
	water_detect();			 
	wash_detect();			 
	ac_freqcy_detect();		 
	lid_detect();			 
	unbalance_detect();		 
}

 





void output(void)
{
	unsigned char i;
	unsigned char j;
	unsigned char k;
	
 
	
  i = output_buff;
	
  if (i == 0)			 
   {
	   p3_addr.bit.b6				 		    = 0; 
	   p8_addr.bit.b2				 		   		 =0;			  
			  
	   p3_addr.bit.b0				 		   		 = 0;
	   p8_addr.bit.b3				 		   	 = 0;
			  
	   p6_addr.bit.b5				 		   		 = 0;
	   p8_addr.bit.b4				 		   		 = 0;
			  
	   p8_addr.bit.b0				 		    = 0;
	   p1_addr.bit.b4				 		    = 0;
			  
	   p4_addr.bit.b5				 		    = 0;
	   p8_addr.bit.b5				 		    = 0;
			  
	   p6_addr.bit.b0				 		   	 = 0;
	   p8_addr.bit.b6				 		    = 0;
			  
	   p8_addr.bit.b1				 		    = 0;
	   p1_addr.bit.b5				 		    = 0;		 
   }
  else if (i != 0)
   {
	for (j = 0; j < 8; j++)
	 {
		 k = (OPT_Table[j] & i);
		 if (k)
		 continue;
		 
		 switch (OPT_Table[j])			 
		  {
			  case 0x01			  :
		 
			  p3_addr.bit.b6				 		    = 0; 
			  p8_addr.bit.b2				 		   		 =0;			  
			  break;
			  
			  
			  case 0x02			  :
			  
			  p3_addr.bit.b0				 		   		 = 0;
			  p8_addr.bit.b3				 		   	 = 0;
			  break;
			  
			  
			  case 0x04			  :
			  
			  p6_addr.bit.b5				 		   		 = 0;
			  p8_addr.bit.b4				 		   		 = 0;
			  break;		
			  
			  
			  case 0x08			  :
			  
			  p8_addr.bit.b0				 		    = 0;
			  p1_addr.bit.b4				 		    = 0;
			  break;	
			  
			  case 0x10			  :
			  
			  p4_addr.bit.b5				 		    = 0;
			  p8_addr.bit.b5				 		    = 0;
			  break;
			  
			  case 0x20			  :
			  
			  p6_addr.bit.b0				 		   	 = 0;
			  p8_addr.bit.b6				 		    = 0;
			  break;		
			  
			  
			  case 0x40			  :
			  
			  p8_addr.bit.b1				 		    = 0;
			  p1_addr.bit.b5				 		    = 0;
			  break;				  			  	  
		  }
	 }	   
	for (j = 0; j < 8; j++)
	 {
		 k = (OPT_Table[j] & i);
		 if (!k)
		 continue;
		 
		 switch (OPT_Table[j])			 
		  {
			  case 0x01			  :
			  
			  p3_addr.bit.b6				 		    = 1;
			  p8_addr.bit.b2				 		   		 = 1;	  
			  break;
			  
			  
			  case 0x02			  :
			  
			  p3_addr.bit.b0				 		   		 = 1;
			  p8_addr.bit.b3				 		   	 = 1;
			  break;
			  
			  
			  case 0x04			  :
			  
			  p6_addr.bit.b5				 		   		 = 1;
			  p8_addr.bit.b4				 		   		 = 1;
			  break;		
			  
			  
			  case 0x08			  :
			  
			  p8_addr.bit.b0				 		    = 1;
			  p1_addr.bit.b4				 		    = 1;
			  break;	
			  
			  case 0x10			  :
			  
			  p4_addr.bit.b5				 		    = 1;
			  p8_addr.bit.b5				 		    = 1;
			  break;
			  
			  case 0x20			  :
			  
			  p6_addr.bit.b0				 		   	 = 1;
			  p8_addr.bit.b6				 		    = 1;
			  break;		
			  
			  
			  case 0x40			  :
			  
			  p8_addr.bit.b1				 		    = 1;
			  p1_addr.bit.b5				 		    = 1;
			  break;				  			  	  
		  }
	 }
   }
   
  return;
  
}

 





void water_detect(void)
{
	unsigned char i;
	
	machine_type = p3_addr.bit.b5				 		  ;
	
	if (machine_type == 0)								 
	 {
		 if ((output_buff & 0x04			  ) != 0);				 
		  {
			  if (inlet_2m_buff <= 30)					 
			   {
				    water_buff = water_level_buff;
		 			operation_flag_5.f_bit.fb0		 	 = 1;
		 			operation_flag_5.f_bit.fb2		 	 = 0;				   
			   }
			  
		  }
		  
		 if ((output_buff & 0x02			  ) != 0);				 
		  {
			  if (drain_2m_buff <= 30)					 
			   {
		 			water_buff = 0;
		 			operation_flag_5.f_bit.fb0		 	 = 0;				   
			   }
			  
		  }		  	
		    
		 return;							 
		 
	 }
	
	i = p3_addr.bit.b3				 		  ;							 
	
	if (i != 0)								 
	water_buff = water_level_buff;
	else if (i == 0)						 
	water_buff = 0;
	
	if (water_buff == water_level_buff)
	 {
		 operation_flag_5.f_bit.fb0		 	 = 1;				 
		 operation_flag_5.f_bit.fb2		 	 = 0;
	 }
	else if ((water_buff < water_level_buff)||(water_buff == 0))
	operation_flag_5.f_bit.fb0		 	 = 0;					 
	return;
}

 





void wash_detect(void)
{
	unsigned char j;
	
	machine_type = p3_addr.bit.b5				 		  ;
	
	if (machine_type == 0)				 
	return;	
	
	j = p3_addr.bit.b4				 		  ;								 
	
	if (j != 0)							 
	 {
		run_stream_time = 30;			
		
  		soak_1m_buff = 30;
  		soak_2m_buff = 30;
  		soak_3m_buff = 30;
  		soak_4m_buff = 30;
  		soak_9m_buff = 30;
		process_left_time = 30;
	 }
	
	return;
}

 





void lid_detect(void)
{
	unsigned char j;
		
	machine_type = p3_addr.bit.b5				 		  ;
	
	if (machine_type == 0)					 
	 {
		 j = p3_addr.bit.b3				 		  ;							 
		 
		 if (j != save_lid_status)
		  {			  
			  if (save_lid_status == 0)
			   {
				   if((process_flag_2.f_bit.fb5		 		 == 1)||(save_water_flag_1.f_bit.fb1		  == 1))
				   save_water_flag_1.f_bit.fb4		  = 1;
			   }	
			   		  
			  save_lid_status = j;		
			  	  			  
		  }		 
		  
		 if (j == 1)						 
		  {
			  lid_open = 0;
		  }
		  
		 if (j == 0)						 
		  {
			  lid_open = 1;
		  }		  
		  
	 }
	 
}

 





void unbalance_detect(void)
{	
	unsigned char j;
			
	machine_type = p3_addr.bit.b5				 		  ;
	
	if (machine_type == 0)								 
	 {
		 j = p3_addr.bit.b4				 		  ;										 
		 
		 if (j == 0)
		  {
			 if ((program_buff == 0xb				   )&&(status_buff == 0x02				  ))
			 err_buff = 0x04		    ;
			 
			 else 
			  {
				  if (((output_buff & 0x01			  ) != 0)||((output_buff & 0x10			  ) != 0))
			 	  unbalance_count ++;	
					
			 	  if (unbalance_count == 3)
			 	  {
			 		  unbalance_count = 0;
			 		  operation_flag_5.f_bit.fb3		 	 = 1;
					  err_buff = 0x04		    ;
			 	  }		

			  }

		  }
	 }
}

 





void ac_freqcy_detect(void)
{
	
	if ((ac_frequency >= 49)&&(ac_frequency <= 51))
	ac_frequency = 50;
	
	else if ((ac_frequency >= 59)&&(ac_frequency <= 61))
	ac_frequency = 60;
	
}

 





void demo_judge(void)
{
	machine_type = p3_addr.bit.b5				 		  ;	
	
	if (machine_type == 0)					 
	 {
		operation_flag_1.f_bit.fb5		  = 1;
		
		menu_level_buff = 0x04				  ;
		
		program_buff = 0x00				  ;				

	 }
	 
	 else 
	 operation_flag_1.f_bit.fb5		  = 0;

}

 







unsigned char program_time(unsigned char far * table_adr, unsigned char table_colum)
{
	unsigned char i;
	
	unsigned int total_time = 0;
	unsigned char left_time = 0;
	unsigned int pass_time = 0;

	
    for (i = 0; i < table_colum; i++)
     {	 
		if ((i == 1)&&(program_buff != 0xb				   ))						 
		{	
			total_time += main_soak_time * 60;
			
			if (i == operation_counter)
			pass_time = (total_time - process_left_time);
						
			continue;
		}
			 
		if ((i == 2)&&(program_buff != 0xb				   ))						 
		{			
			total_time += main_wash_time * 60;
			
			if (i == operation_counter)
			pass_time = (total_time - process_left_time);
						
			continue;
		}
			 
		if ((i == (table_colum - 3))&&(program_buff != 0xb				   ))		 
		{
			
			if (spin_time_buff == 6)			  
			total_time += table_adr[i] * 60;
			  
			if (spin_time_buff != 6)
			total_time += spin_time_buff * 60;				
									
			if (i == operation_counter)
			pass_time = (total_time - process_left_time);			
			
			continue;
		}
			 
		if (i == operation_counter)						 
		 {								
			total_time += table_adr[i];		 
			
			if ((i==0)&&(operation_flag_3.f_bit.fb4		  == 1))
			 {
				 operation_flag_3.f_bit.fb4		  = 0;
				 process_left_time = 120;
				 
				 if (program_buff == 0xb				   )
				 process_left_time = 5;
				 
				 pass_time = (total_time - process_left_time);				 
				 continue;
			 }
			
			pass_time = (total_time - process_left_time);				 
			
			if (program_buff == 0xb				   )
			 {
				  pass_time = (total_time - process_left_time/60);			
				  if ((process_left_time % 60) > 30)
				  pass_time -= 1;
			 }
									
			continue;
		 }		
		 
		total_time += table_adr[i];						 
			
 
 
 
 
     }		
	 
	if (program_buff == 0xb				   ) 
	 {
		left_time = total_time - pass_time;
		process_left_time = 300;
	 }
	
	else 
	 {
		left_time = (total_time - pass_time)/60;		 
	
		if ((left_time % 60) > 30)
		left_time += 1;									 
	 }
	
    return left_time;									 

}

 







void eeprom_write(void)
{
	static unsigned char i=0;
	static unsigned char j=0;	
	
	IicPack IicData_w;
	
	IicData_w.iic_DeviceAddress = 0xa0;				 
	IicData_w.iic_MemoryAddress = 0x00;				 
 
	IicData_w.iic_Data = (unsigned char *)0x00aa5 ;					 
	IicData_w.iic_NumberOfByte = 8;					 
	
	for (j = 0; j <= 30; j++)						 
	 {
		 if (j == 30)
		  {
			  IicData_w.iic_NumberOfByte = 5;
			  
			  initIicBus();
			  IicBusWrite(&IicData_w);			  
			  break;
		  }
		  
		 initIicBus();
		 
		 IicBusWrite(&IicData_w);
		 
		 asm("nop");
		 
		 IicData_w.iic_MemoryAddress += 8;		 
 
		 
		 epprom_4ms_buff = 1;
		 
		 while (epprom_4ms_buff)
		 {
		 	asm("nop");
		 }		 
	 }	
	
	asm("nop");
	asm("nop");
	asm("nop");
	
}

 







void eeprom_read(void)
{
	static unsigned char i=0;
	static unsigned char j=0;	
	
	IicPack IicData_w;	
	IicPack IicData_r;
	
	IicData_r.iic_DeviceAddress = 0xa0;		 
	IicData_r.iic_MemoryAddress = 0x40;		 
 
	IicData_r.iic_Data = (unsigned char *)0x00900 ;			 
	IicData_r.iic_NumberOfByte = 0x08;		 
	
	initIicBus();	
	
	IicBusRead(&IicData_r);			 
	
	asm("nop");
	asm("nop");
	asm("nop");
	
	if((*(unsigned char *)0x00906) == 1)				 
	 {
	 
		IicData_r.iic_DeviceAddress = 0xa0;
		IicData_r.iic_MemoryAddress = 0x00;		 
		IicData_r.iic_Data = (unsigned char *)0x00400 ;
		IicData_r.iic_NumberOfByte = 0xF5;
	
		initIicBus();	
	
		IicBusRead(&IicData_r);		 
	
		asm("nop");
		asm("nop");
		asm("nop");	
		asm("nop");
		asm("nop");
		asm("nop");			
		
		(*(unsigned char *)0x00906) = 0;				 
		
		IicData_w.iic_DeviceAddress = 0xa0;
		IicData_w.iic_MemoryAddress = 0x40;
		IicData_w.iic_Data = (unsigned char *)0x00900 ;	
		IicData_w.iic_NumberOfByte = 8;	
		
		initIicBus();
		IicBusWrite(&IicData_w);	 
		
		asm("nop");
		asm("nop");
		asm("nop");	
		asm("nop");
		asm("nop");
		asm("nop");		
		
		operation_flag_3.f_bit.fb3		  = 1;			 					
	
	 }
	 
}

 






void initIicBus(void)
{
	pd4_addr.bit.b3				 		  = 0; 					 
	pd4_addr.bit.b4				  = 0; 					 
}

 

 






unsigned char IicBusRead(IicPack *IicData)
{
	unsigned char i,ret;											 
	
	IicData->iic_DeviceAddress &= 0xFE; 							 
	StartCondition(); 												 
	
	while (1) 
	 {
		
		if ((ret=ByteWrite(IicData->iic_DeviceAddress)) == 1				  )	 
		break; 		
																	 
		if ((ret=ByteWrite(IicData->iic_MemoryAddress)) == 1				  )
																	 
		break; 														 

		IicData->iic_DeviceAddress |= 0x01; 						 
		StartCondition(); 											 
		if ((ret=ByteWrite(IicData->iic_DeviceAddress)) == 1				  )
																	 
		break; 	
																	 
		for (i=1; i<IicData->iic_NumberOfByte; i++) 
		 { 															 
			ByteRead (IicData->iic_Data, 0				  ); 						 
			IicData->iic_Data++; 									 
		 }
	 
		ByteRead (IicData->iic_Data, 1				  ); 						 
		break;
	 }
	StopCondition(); 												 
	return(ret);
}

 

 





unsigned char IicBusWrite(IicPack *IicData)
{
	unsigned char i,ret;
																	 
	IicData->iic_DeviceAddress &= 0xFE; 							 
	StartCondition(); 												 
	while (1) 
	 {
		if ((ret=ByteWrite(IicData->iic_DeviceAddress)) == 1				  )
																	 
		break; 														 
		if ((ret=ByteWrite(IicData->iic_MemoryAddress)) == 1				  )
																	 
		break; 														 
		for (i=0; i<IicData->iic_NumberOfByte; i++)					 
	 	 { 					
			if ((ret=ByteWrite(*(IicData->iic_Data))) == 1				  ) 	 
			break; 													 
			IicData->iic_Data++; 									 
	 	 }
		break;
	 }	
	
	StopCondition(); 												 
	return(ret);
	
}

 

 






void StartCondition(void)
{
	p4_addr.bit.b4				  = 0; 						 
	pd4_addr.bit.b4				  = 1; 						 
	_WaitTime1us(); 					 
	pd4_addr.bit.b3				 		  = 0; 						 
	_WaitTime1us(); 					 
	_WaitTime1us(); 					 
	p4_addr.bit.b4				  = 1; 						 
	_WaitTime1us() 			  ; 						 
	p4_addr.bit.b3				  = 0; 						 
	pd4_addr.bit.b3				 		  = 1; 						 
	_WaitTime1us() 			  ; 						 
	_WaitTime1us(); 					 
	p4_addr.bit.b4				  = 0; 						 
}
 






void StopCondition(void)
{
	p4_addr.bit.b4				  = 0; 						 
	pd4_addr.bit.b4				  = 1; 						 
	_WaitTime1us(); 					 
	p4_addr.bit.b3				  = 0; 						 
	pd4_addr.bit.b3				 		  = 1; 						 
	_WaitTime1us(); 					 
	p4_addr.bit.b4				  = 1; 						 
	_WaitTime1us() 			  ; 						 
	pd4_addr.bit.b3				 		  = 0; 						 
	_WaitTime1us(); 					 
	_WaitTime1us(); 					 
	p4_addr.bit.b4				  = 0; 						 
}

 

 






unsigned char ByteWrite(unsigned char iic_writeData)
{
	unsigned char maskData = 0x80; 						 
	unsigned char ret = 0				  ; 								 
	
	while (maskData) 
	 { 									 
		p4_addr.bit.b3				  = 0; 										 
		if (iic_writeData & maskData) 
		 { 								 
			pd4_addr.bit.b3				 		  = 0; 										 
		 }
		 
		else
		 {
			pd4_addr.bit.b3				 		  = 1; 										 
			asm("nop"); 										 
			asm("nop"); 										 
			asm("nop"); 										 
		 }
		 
		_WaitTime1us() 			  ; 										 
		_WaitTime1us(); 									 
		p4_addr.bit.b4				  = 1; 										 
		_WaitTime1us() 			  ; 										 
		_WaitTime1us(); 									 
		p4_addr.bit.b4				  = 0; 										 
		maskData >>= 1; 									 
		_WaitTime1us(); 									 
		
	 }
	 
		pd4_addr.bit.b3				 		  = 0; 										 
		_WaitTime1us() 			  ; 											 
		_WaitTime2us(); 									 
		p4_addr.bit.b4				  = 1; 										 
		
		if (p4_addr.bit.b3				  ) 
		ret=1				  ; 											 
		
		_WaitTime1us() 			  ; 										 
		
		_WaitTime1us(); 									 
		p4_addr.bit.b4				  = 0; 										 
		_WaitTime0us() 			  ; 										 
		
		return(ret);
		
}

 

 






void ByteRead(unsigned char *iic_readData, unsigned char ackData)
{
	unsigned char maskData=0x80; 						 
	unsigned char readData;
	
	*iic_readData = 0; 									 
	
	while (maskData) 
	 { 													 
		readData = *iic_readData | maskData; 			 
		pd4_addr.bit.b3				 		  = 0; 									 
		_WaitTime1us() 			  ; 										 
		p4_addr.bit.b4				  = 1; 									 
	
		if (p4_addr.bit.b3				  ) 
	 	 { 												 
			*iic_readData = readData; 					 
	 	 }
	
		else{
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		asm("nop"); 									 
		}
		
		_WaitTime1us() 			  ; 									 
		_WaitTime1us(); 								 
		p4_addr.bit.b4				  = 0; 									 
		maskData >>= 1; 								 
		_WaitTime1us(); 								 
	 }
	 
	if (!ackData) 
	 { 													 
														 
		p4_addr.bit.b3				  = 0				  ; 									 
		pd4_addr.bit.b3				 		  = 1; 									 
	 } 
	 
	else
	 {
														 
		p4_addr.bit.b3				  = 1				  ; 								 
		pd4_addr.bit.b3				 		  = 0; 									 
   	}
	 
	_WaitTime1us() 			  ; 										 
	_WaitTime1us(); 									 
	p4_addr.bit.b4				  = 1; 										 

 

	_WaitTime1us() 			  ; 										 
	_WaitTime1us(); 									 
	p4_addr.bit.b4				  = 0; 										 
	pd4_addr.bit.b3				 		  = 0; 										 
	_WaitTime1us(); 									 
	
}
 





void _WaitTime0us(void)
{
	;
}
 





void _WaitTime1us(void)
{											 
	asm("nop"); 							 
	asm("nop"); 							 
}
 





void _WaitTime2us(void)
{
											 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
	asm("nop"); 							 
}