output.i

电表解决方案概要power_meter_r8c2g_source_code

extern	unsigned char t1_3key_flag;
extern	unsigned char test1_flag;
extern	unsigned char test_1_mode;
extern	unsigned char test_1_start_flag;
extern	unsigned char t1_2key_flag;

extern	unsigned char test_buff;
extern	unsigned char t_mode_switch_flag;
extern	unsigned char test_inlet_flag;
extern	unsigned char test_softner_flag;


extern	unsigned char default_flag;

extern	signed char run_1s_buff;
extern	unsigned char test_start_flag;
extern	unsigned char t1_switch_3s_buff;
extern	unsigned char test_1_3s_buff;
 
extern	unsigned char buzz_buff;
 
extern	unsigned char t1_end_3s_buff;
extern	unsigned char t1_finish_flag;
extern	unsigned char pro_flash_flag;
extern	unsigned char stream_run;
extern	unsigned char stream_stop;
 
extern	unsigned char finish;
extern	unsigned char key_release;
extern	unsigned char test_2_3s_buff;
extern	unsigned char test_2_7s_buff;
 

extern	signed char check_2s_buff;
extern	signed char kaiji_3s_buff;
extern	unsigned char power_key_flag;
extern	unsigned char run_water_key_flag;

extern	signed char inlet_10s_buff;
extern	signed int inlet_20m_buff;
extern	signed char inlet_2m_buff;
extern	unsigned char cycle_start_flag;

extern	signed int drain_8m_buff;
extern	signed char drain_2m_buff;
extern	signed char drain_60s_buff;
extern	signed char drain_10s_buff;
extern	signed char drain_20s_buff;

extern	unsigned char main_soak_time;
extern	unsigned char main_wash_time;

extern	unsigned char soak_flash_flag;
extern	unsigned char wash_flash_flag;
extern	unsigned char rinse_flash_flag;
extern	unsigned char spin_flash_flag;

 
 
 

extern	signed char soak_1m_buff;
extern	signed char soak_2m_buff;
extern	unsigned char soak_3m_buff;
extern	unsigned char soak_4m_buff;
extern	signed int soak_9m_buff;

extern	unsigned char soak_1_cycle_buff;
extern	unsigned char soak_2_cycle_buff;
extern	unsigned char soak_3_cycle_buff;

extern	unsigned int run_stream_time;
extern	unsigned char balance_time_buff;
extern	unsigned char wash_start_flag;
extern	unsigned char wash_finish_flag;

extern	unsigned char interm_spin_10s_buff;
extern	unsigned char interm_spin_5s_buff;
extern	unsigned char interm_spin_4s_buff;
extern	unsigned char interm_spin_3s_buff;


 
 

extern	unsigned char spin_balance_time_buff;

extern	signed char inertial_30s_buff;
extern	signed char break_5s_buff;

 


extern	unsigned char output_buff;
extern	unsigned char save_output_buff;
extern	unsigned char machine_type;
extern	unsigned char err_buff;

extern	signed int process_left_time;
extern	unsigned char total_run_time;
extern	unsigned char total_left_time;

extern	unsigned char water_level_buff;
 

extern	unsigned char status_buff;
extern	unsigned char lid_open;
 
extern	unsigned char manual_process_buff;

extern	unsigned char ac_frequency;
extern	unsigned char stream_table_row;
extern	unsigned char ext_stream_table_row;

extern	unsigned char main_stream_time;
extern	unsigned char ext_stream_time;

extern	unsigned char mot_cycle_buff;
extern	unsigned char stream_buff;
extern	signed char stream_100ms_buff;
extern	signed char base_100ms_buff;

 
 
extern	unsigned char stream_start_flag;
extern	unsigned char stream_stop_flag;

extern	unsigned char pro_default_flag;

extern	unsigned char program_left_time;
 

extern	unsigned char key_buzz_flag;
extern	unsigned char buzz_flag;  

extern	signed char buzz_24ms_buff;

extern	signed char buzz_15m_buff;
extern	signed char buzz_switch_flag;
extern	signed char buzz_500ms_buff;
extern	signed char buzz_time;        


 



extern union byte_def_1 {

	volatile unsigned char byte;

	struct{

	unsigned char b0:1;
	unsigned char b1:1;
	unsigned char b2:1;
	unsigned char b3:1;
	unsigned char b4:1;
	unsigned char b5:1;
	unsigned char b6:1;
	unsigned char b7:1;

	}bi;
};



extern struct{
	
	union byte_def_1 led_0;
	union byte_def_1 led_1;
	union byte_def_1 led_2;
	union byte_def_1 led_3;
	union byte_def_1 led_4;
	
}led_disp;

extern struct{
	
	union byte_def_1 key_flag;
	union byte_def_1 flash;
	union byte_def_1 flag_2;
	union byte_def_1 flag_3;
	union byte_def_1 flag_4;
	
}flag;



extern struct struct_table{
	
	unsigned int run;
	unsigned int stop;
	
};

extern const struct struct_table Stream_Table_A[18][3];
extern const struct struct_table Stream_Table_B[12][3];
extern const struct struct_table Stream_Table_Ext_A[4][2];
extern const struct struct_table Stream_Table_Ext_B[4][2];
extern const struct struct_table Stream_Table_TEST[3][2];

extern const struct struct_table Balance_Stream_A[2];
extern const struct struct_table Speedy_Stream_A[4];
extern const struct struct_table Fastest_Stream_A[2];

 

 

extern const unsigned char Standard_Time_Table[21];

extern const unsigned char Memo_Time_Table[25];

extern const unsigned char Strong_Time_Table[23];

extern const unsigned char Silk_Time_Table[21];

extern const unsigned char Soft_Time_Table[33];

extern const unsigned char Child_Time_Table[33];

extern const unsigned char Wool_Time_Table[25];

extern const unsigned char Speedy_Time_Table[14];

extern const unsigned char Fastest_Time_Table[16];

extern const unsigned char TubeDry_Time_Table[7];


extern const unsigned char Single_Wash_Time_Table[];

extern const unsigned char Rinse_Time_Table[];

extern const unsigned char Single_Spin_Time_Table[];


extern const unsigned char Woven_Time_Table[33];

extern const unsigned char Maotan_Time_Table[33];

 

 

 

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"


#pragma SECTION program pro_4

void balance_stream(unsigned char stream_time);

 








void led(void);
void buzz(void);

void water_detect(void);
void wash_detect(void);
 

 

unsigned char water_led_buff;
 

void led(void)
{
	unsigned char i;
	unsigned char j;
	return;
}

 







 

void	key_buzz(void);              
void	eoc_buzz(void);              
void	err_buzz(void);       
void	save_water_buzz(void);    


void alarm(void)
{
 if (err_buff)
 run_err_flag = 1;
 
 if (run_save_water_flag == 1)
  {
	  status_buff = 0x03 ;
	  buzz_flag = 1;
  }
 if (run_save_water_flag == 1)
  {
	  status_buff = 0x03 ;	  

  }
 if (run_save_water_flag == 1)
  {
	  status_buff = 0x03 ;	  
  }
  
  save_water_buzz();
  
}
  

void	buzz(void)
{
	key_buzz();
	return;
}     


void	key_buzz(void)
{
	return;
}

void	eoc_buzz(void)
{
	;
}

void	save_water_buzz(void)
{
;
}

void	err_buzz(void) 
{
	;
}


 







void err(void)
{
	;
}

void input(void)
{
	water_detect();
	wash_detect();
}


void output(void)
{
	unsigned char i;
	unsigned char j;
	unsigned char k;
	
  buzz();
	
  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;
			  
	   p4_addr.bit.b5				  = 0;
	   p8_addr.bit.b5				  = 0;
			  
	   p6_addr.bit.b0				 	 = 0;
	   p8_addr.bit.b6				  = 0;
			  
	   p8_addr.bit.b0				  = 0;
	   p1_addr.bit.b4				  = 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 :
			  
			  p4_addr.bit.b5				  = 0;
			  p8_addr.bit.b5				  = 0;
			  break;	
			  
			  case 0x10 :
			  
			  p6_addr.bit.b0				 	 = 0;
			  p8_addr.bit.b6				  = 0;
			  break;
			  
			  case 0x20 :
			  
			  p8_addr.bit.b0				  = 0;
			  p1_addr.bit.b4				  = 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 :
			  
			  p4_addr.bit.b5				  = 1;
			  p8_addr.bit.b5				  = 1;
			  break;	
			  
			  case 0x10 :
			  
			  p6_addr.bit.b0				 	 = 1;
			  p8_addr.bit.b6				  = 1;
			  break;
			  
			  case 0x20 :
			  
			  p8_addr.bit.b0				  = 1;
			  p1_addr.bit.b4				  = 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 = 0x00 ;
	
	i = p0_addr.bit.b6				  ;
	
	if (i != 0)
	water_buff = water_level_buff;
	else if (i == 0)
	water_buff = 0;
	
	if (water_buff == water_level_buff)
	 {
		 water_full_flag = 1;
		 drain_empty_flag = 0;
	 }
	else if ((water_buff < water_level_buff)||(water_buff == 0))
	water_full_flag = 0;
	return;
}

void wash_detect(void)
{
	unsigned char j;
	
	machine_type = 0x00 ;
	
	j = p0_addr.bit.b7				  ;
	
	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;
}

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

	
    for (i = 0; i < table_colum; i++)
     {	 
		if (i == 1)
		{	
			total_time += main_soak_time * 60;
			
			if (i == operation_counter)
			pass_time = (total_time - process_left_time);
						
			continue;
		}
			 
		if (i == 2)
		{			
			total_time += main_wash_time * 60;
			
			if (i == operation_counter)
			pass_time = (total_time - process_left_time);
						
			continue;
		}
			 
		if (i == (table_colum - 2))
		{		
			total_time += table_adr[i] * 60;
			
			if (i == operation_counter)
			pass_time = (total_time - process_left_time);			
			
			continue;
		}
			 
		if (i == operation_counter)
		 {								
			total_time += table_adr[i];		 
			
			pass_time = (total_time - process_left_time);	
						
			continue;
		 }		
		 
		total_time += table_adr[i];
			
 
 
 
 
     }		 
	 
	left_time = (total_time - pass_time)/60;	
    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 *)0x0042a ;	
	IicData_w.iic_NumberOfByte = 8;
	
	for (j = 0; j < 32; j++)
	 {
		 initIicBus();
		 IicBusWrite(&IicData_w);
		 
		 IicData_w.iic_MemoryAddress += 8;		 
		 IicData_w.iic_Data += 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_r;
	
	IicData_r.iic_DeviceAddress = 0xa0;
	IicData_r.iic_MemoryAddress = 0x00;
 
	IicData_r.iic_Data = (unsigned char *)0x00900 ;	
	IicData_r.iic_NumberOfByte = 0xff;
	
	initIicBus();	
	
	IicBusRead(&IicData_r);
	
	asm("nop");
	asm("nop");
	asm("nop");
}

 






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"); 							 
}