#include "STC8.H"
#include <intrins.h>

/*************** 宏定义 **************/
#define   FOSC            11059200UL                  //MCU工作频率为11.0592MHz
#define   BRT             (65536 - FOSC / 115200 / 4) //串口通信波特率为115200

#define   IAP_ADDRESS     0x0000

#define   LED_ON          P00 = 0
#define   LED_OFF         P00 = 1

#define   WT_30M          0x80
#define   WT_24M          0x81
#define   WT_20M          0x82
#define   WT_12M          0x83
#define   WT_6M           0x84
#define   WT_3M           0x85
#define   WT_2M           0x86
#define   WT_1M           0x87

#define		ISP_STANDBY()	ISP_CMD = 0		/* ISP空闲命令（禁止）*/
#define		ISP_READ()		ISP_CMD = 1		/* ISP读出命令		*/
#define		ISP_WRITE()		ISP_CMD = 2		/* ISP写入命令		*/
#define		ISP_ERASE()		ISP_CMD = 3		/* ISP擦除命令		*/

//sfr ISP_TRIG  = 0xC6;
#define 	ISP_TRIG()	ISP_TRIG = 0x5A,	ISP_TRIG = 0xA5		/* ISP触发命令 */

//							  7    6    5      4    3    2    1     0    Reset Value
//sfr ISP_CONTR = 0xC7;		ISPEN SWBS SWRST CFAIL  -   WT2  WT1   WT0   0000,x000	//ISP Control Register
#define ISP_EN			    (1<<7)
#define ISP_SWBS		    (1<<6)
#define ISP_SWRST		    (1<<5)
#define ISP_CMD_FAIL	  (1<<4)
#define ISP_WAIT_1MHZ	  7
#define ISP_WAIT_2MHZ	  6
#define ISP_WAIT_3MHZ	  5
#define ISP_WAIT_6MHZ	  4
#define ISP_WAIT_12MHZ	3
#define ISP_WAIT_20MHZ	2
#define ISP_WAIT_24MHZ	1
#define ISP_WAIT_30MHZ	0

#if (FOSC >= 24000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_30MHZ
#elif (FOSC >= 20000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_24MHZ
#elif (FOSC >= 12000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_20MHZ
#elif (FOSC >= 6000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_12MHZ
#elif (FOSC >= 3000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_6MHZ
#elif (FOSC >= 2000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_3MHZ
#elif (FOSC >= 1000000L)
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_2MHZ
#else
	#define		ISP_WAIT_FREQUENCY	ISP_WAIT_1MHZ
#endif

/***************函数声明**************/
void PWM_Init();
void PWM_TO_DAC(unsigned int PowerVol,unsigned int OutVol);
void Timer0_Init();
void UART1_Init();
void ADC_Init();
void UartSendData(void);
void DataParsing(void);
void AutoAction(void);
void Read_ADC();
void Delay10ms();
void DisableEEPROM(void);
void EEPROM_read_n(unsigned int EE_address,unsigned char *DataAddress,unsigned int number);
void EEPROM_SectorErase(unsigned int EE_address);
void EEPROM_write_n(unsigned int EE_address,unsigned char *DataAddress,unsigned int number);
void Parameter_Save(void);

unsigned int Get_ADC12bitResult(unsigned char channel);	//channel = 0~14
unsigned int ADC_Average(unsigned int *buff,unsigned int num,unsigned int threshold);

/***************变量定义**************/
bit  busy     = 0;
bit  SendEN   = 0;
bit  SendInit = 0;
bit  Rx_Busy  = 0;

bit  PWM_ON   = 0;

bit  Uart1Ready_R = 0;
bit  AcqInitFlag  = 0;
bit  AD_Refresh   = 0;
bit  Save_Flag    = 0;

bit  PWM_ON_EN    = 0;

unsigned char xdata Rxbuff[20];
unsigned char xdata aRxBufferTemp = 0;
unsigned char xdata RX_5A_OK=0,RX_A5_OK=0;
unsigned char xdata Rx_count_UART1= 0;      //UART1接收计数器
unsigned char xdata Rx_Cnt = 0;

unsigned char xdata SendBuffer[50];

unsigned char xdata TableRead[50];
unsigned char xdata TableWrite[50];

unsigned int xdata ADC_EXT_Value = 0;
unsigned int xdata ADC0_Value    = 0;
unsigned int xdata ADC1_Value    = 0;
unsigned int xdata ADC2_Value    = 0;

unsigned int xdata TwinkleCnt    = 0;

unsigned int xdata Cnt = 0,Times = 0,AcqInitCnt = 0;
unsigned int xdata UartCnt = 0;
unsigned int xdata SentCnt = 0;
unsigned int xdata ADC_Cnt = 0;

unsigned int xdata Time_Cnt = 0,Time_Sec = 0,Time_Min = 0,Save_Cnt = 0;

unsigned int xdata ADC_EXT_Temp[120];

unsigned int xdata ADC0_Temp[120];
unsigned int xdata ADC1_Temp[120];
unsigned int xdata ADC2_Temp[120];

unsigned int xdata RunTime    = 0;	    //运行时间
unsigned int xdata InVoltage  = 12000;  //输入电压
unsigned int xdata OutVoltage = 0;	    //输出电压

unsigned int xdata EXT_Value  = 0;      //外部电压

unsigned int xdata SetVoltage = 0;	    //设置电压
unsigned int xdata SetCorroV  = 0;	    //腐蚀电压
unsigned int xdata AcqVolatage= 0;	    //采集电压
unsigned int xdata OutCurrent = 0;        //输出电流(放大10倍后屏显示的电流)

unsigned int xdata OutSet     = 0;        //输出设置
unsigned int xdata DisSet     = 0;        //显示设置

unsigned int xdata OutTemp;

unsigned int xdata CalibrationVoltage = 0; //设定的输出电压

unsigned int xdata InitAcqVolatage    = 0; //初始采集电压
unsigned int xdata InitAcqCurrent     = 0; //初始采集电流

unsigned int xdata AcqVolatage1 = 0;       //采集电压1

unsigned int xdata Limitvoltage = 0;       //极限电压

unsigned int xdata Temp01 = 0;             //辅助运算
unsigned int xdata Temp02 = 0;

unsigned int xdata AcqError  = 0;          //实时采集误差
unsigned int xdata InitError = 0;          //初始误差

unsigned char xdata Shut_Hour = 0;
unsigned char xdata Shut_Min  = 0;
unsigned char xdata Shut_Sec  = 0;
unsigned int  xdata Shut_MS   = 0;

int OffsetVoltage = 0;	                   //补偿电压

 
float xdata IA;                            //实际输出电流
float xdata CurrentError = 0; 
float xdata AdjVoltage = 0;		             //调节电压	
float xdata CompensationValue = 0;         //补偿系数
float xdata OutGain = 0;                   //输出增益调节

/*************** 主函数 **************/
void main()
{
  Timer0_Init();
  PWM_Init();
  UART1_Init();
  ADC_Init();
  
  ES = 1;
  EA = 1;
  UartCnt = 0;
  SendEN  = 0;
  ADC_Cnt = 0;
  Times   = 0;
 
  Delay10ms();
  Delay10ms();
  Delay10ms();
  Delay10ms();
  
  EEPROM_read_n(IAP_ADDRESS,TableRead,18);   //从EEPROM读取数据
	
	RunTime 	   = TableRead[0] *256UL + TableRead[1] ;                //读EEPROM数据--运行时间
	SetVoltage   = TableRead[2] *256UL + TableRead[3] ;                //读EEPROM数据--设置电压
	SetCorroV    = TableRead[4] *256UL + TableRead[5] ;                //读EEPROM数据--腐蚀电压
	
  OutSet       = TableRead[6] *256UL + TableRead[7] ;                //读EEPROM数据--输出设置
  DisSet       = TableRead[8] *256UL + TableRead[9];                 //读EEPROM数据--显示设置
	CurrentError = (float)(TableRead[10] *256UL + TableRead[11])/100 ;  //读EEPROM数据--电流误差 
  AdjVoltage   = (float)(TableRead[12] *256UL + TableRead[13]) ;  // 读EEPROM数据--调节电压
  AcqError     = (float)(TableRead[14] *256UL + TableRead[15])/10 ;  // 读EEPROM数据--采集误差
	Limitvoltage   = TableRead[16]*256UL + TableRead[17];                //读EEPROM数据--极限电压（新增）
  //第一次运行程序，EEPROM数据全是FFFF，进行参数初始化处理
  if(RunTime==0xFFFF)
  {
    RunTime = 0;
  }
  if(SetVoltage==0xFFFF)
  {
    SetVoltage = 2000;
  }
  if(SetCorroV==0xFFFF)
  {
    SetCorroV = 920;
  }
	 if(Limitvoltage==0xFFFF)
  {
    Limitvoltage = 1600;
  }	
  if(AdjVoltage==0xFFFF)
  {
    AdjVoltage = 3;
  }
  if(CurrentError==(0xFFFF)/100.0)
	{
		CurrentError = 1000;
	}
  if(AcqError==(0xFFFF)/10.0)
	{
		AcqError = 100;
	}	
  if(OutSet==0xFFFF)
  {
    OutSet = 10000;
  }
  if(DisSet==0xFFFF)
  {
    DisSet = 16146;
  }
  
  OutGain   = (float)OutSet/10000;
  
  CalibrationVoltage = SetVoltage;
  PWM_TO_DAC(5000,(unsigned int)(CalibrationVoltage *OutGain)+(unsigned int)IA);//供电电压为：5000MV，负载端输出电压为：CalibrationVoltage，单片机口输出电压为：SetOutVoltage/3
  
  AcqInitCnt = 0;
  while (1)
  {
    DataParsing();      //串口数据解析
    UartSendData();     //串口定时发送数据
    Read_ADC();         //AD采集数据处理
    Parameter_Save();	 		
    if(AcqInitFlag==0)      //上电采集初始电压
    {
      if(AcqInitCnt>1000)   //上电3秒内采集初始电压，时间可修改
      {
        InitAcqVolatage = AcqVolatage;          //获取初始电压
        InitAcqCurrent  = (unsigned int)IA;     //获取初始电流

        AcqInitFlag     = 1;
        AcqInitCnt      = 0;
      }
    }
    		
    if(EXT_Value<1000)  //外部电压小于1000mV
    {
//        LED_OFF;     
			LED_ON;	        // 万博专用
      if(AD_Refresh)
      {
        PWM_TO_DAC(5000,0);//PWM输出0V（可能存在死区，适当修改输出值尽可能让输出接近0V）
        AD_Refresh = 0;
      }
    }
    if(EXT_Value>1800)//外部电压大于2000mV
    {
      AutoAction();   //运行自动程序
    }
  }
}

void AutoAction(void)
{
			 if(!PWM_ON_EN)//PWM输出使能
	 		    
	     if(AcqVolatage>=Limitvoltage)//采集电压大于1500mV,或电流小于0.5mA，关闭输出
			{
		     if(AD_Refresh)		
					 
			  LED_ON;	
//					LED_OFF;			 
       {
          PWM_ON_EN = 1;
          Shut_Hour = 0;
          Shut_Min  = 0;
          Shut_Sec  = 0;
          Shut_MS   = 0;
//				  PWM_ON    = 1;				  
				  PWM_TO_DAC(5000,0);
				  AD_Refresh = 0;
        }
			}
			
		 else	
 {
	 {	 	
    //主逻辑	
//	   if((AcqVolatage<500)||(AcqVolatage>SetCorroV+IA*100)) //采集电压小于100MV，输出电压等于设置电压	
		   if(AcqVolatage<400)
    { 			
    //输出电压			
      PWM_TO_DAC(5000,(unsigned int)(SetVoltage*OutGain+(unsigned int)IA));
			AD_Refresh = 0;
			
    }
			else	
	  {		
      if(AD_Refresh)	
    {	
			
    if(AcqVolatage<400)
    {
      AcqVolatage1 = 400;
    }
    else if((AcqVolatage>=400)&&(AcqVolatage<=2000))
    {
      AcqVolatage1 = AcqVolatage;
    }
    else
    {
      AcqVolatage1 =2000;
    }				
    	   
    //根据腐蚀电压补偿       
    if(AcqVolatage1>SetCorroV)                      //采集电压大于设定的腐蚀电压，负补偿
    {	
      Temp01  = AcqVolatage1-SetCorroV;
      
      if((Temp01>=0)&&(Temp01<10))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/5);
      }
      else if((Temp01>=10)&&(Temp01<30))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/10);
      }
      else if((Temp01>=30)&&(Temp01<50))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/15);
      }	
      else if((Temp01>=50)&&(Temp01<70))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/20);
      }	
      else if((Temp01>=70)&&(Temp01<90))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/25);
      }	
      else if((Temp01>=90)&&(Temp01<110))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/30);
      }	
      else if((Temp01>=110)&&(Temp01<130))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/35);
      }
      else if((Temp01>=130)&&(Temp01<150))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/40);
      }	
      else if((Temp01>=150)&&(Temp01<170))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/45);
      }
      else if((Temp01>=170)&&(Temp01<190))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/50);
      }
      else if((Temp01>=190)&&(Temp01<210))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/55);
      }	
      else if((Temp01>=210)&&(Temp01<230))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/60);
      }
        else if((Temp01>=230)&&(Temp01<250))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/65);
      }
      else if((Temp01>=250)&&(Temp01<270))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/70);
      }
      else if((Temp01>=270)&&(Temp01<290))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/75);
      }	
      else if((Temp01>=290)&&(Temp01<310))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/80);
      }	
      else if((Temp01>=310)&&(Temp01<330))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/85);
      }	
      else if((Temp01>=330)&&(Temp01<350))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/90);
      }	
      else if((Temp01>=350)&&(Temp01<370))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/95);
      }	
      else if((Temp01>=370)&&(Temp01<390))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/100);
      }
      else if((Temp01>=390)&&(Temp01<410))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/105);
      }	
      else if((Temp01>=410)&&(Temp01<430))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/110);
      }
      else if((Temp01>=430)&&(Temp01<450))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/115);
      }	
      else if((Temp01>=450)&&(Temp01<470))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/120);
      }	
      else if((Temp01>=470)&&(Temp01<490))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/125);
      }	
      else if((Temp01>=490)&&(Temp01<510))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/130);
      }	
      else if((Temp01>=510)&&(Temp01<530))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/135);
      }
      else if((Temp01>=530)&&(Temp01<550))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/140);
      }	
      else if((Temp01>=550)&&(Temp01<570))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/145);
      }
      else if((Temp01>=570)&&(Temp01<590))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/150);
      }
      else if((Temp01>=590)&&(Temp01<610))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/155);
      }	
      else if((Temp01>=610)&&(Temp01<630))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/160);
      }
      else if((Temp01>=630)&&(Temp01<650))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/165);
      }
      else if((Temp01>=650)&&(Temp01<670))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/170);
      }
      else if((Temp01>=670)&&(Temp01<690))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/175);
      }	
      else if((Temp01>=690)&&(Temp01<710))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/180);
      }	
      else if((Temp01>=710)&&(Temp01<730))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/185);
      }	
      else if((Temp01>=730)&&(Temp01<750))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/190);
      }	
      else if((Temp01>=750)&&(Temp01<770))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/195);
      }	
      else if((Temp01>=770)&&(Temp01<790))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/200);
      }
      else if((Temp01>=790)&&(Temp01<810))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/205);
      }
      else if((Temp01>=810)&&(Temp01<830))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/210);
      }	
      else if((Temp01>=830)&&(Temp01<850))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/215);
      }	
      else if((Temp01>=850)&&(Temp01<870))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/220);
      }	
      else if((Temp01>=870)&&(Temp01<890))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/225);
      }
      else if((Temp01>=890)&&(Temp01<910))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/230);
      }	
      else if((Temp01>=910)&&(Temp01<930))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/235);
      }	
      else if((Temp01>=930)&&(Temp01<950))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/240);
      }	
      else if((Temp01>=950)&&(Temp01<970))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/245);
      }	
      else if((Temp01>=970)&&(Temp01<990))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/250);
      }
      else if((Temp01>=990)&&(Temp01<1010))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/255);
      }	
      else if((Temp01>=1010)&&(Temp01<1030))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/260);
      }	
      else if((Temp01>=1030)&&(Temp01<1050))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/265);
      }	
      else if((Temp01>=1050)&&(Temp01<1070))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/270);
      }	
      else if((Temp01>=1070)&&(Temp01<1090))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/275);
      }
      else if((Temp01>=1090)&&(Temp01<1110))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/280);
      }	
      else if((Temp01>=1110)&&(Temp01<1130))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/285);
      }	
      else if((Temp01>=1130)&&(Temp01<1150))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/290);
      }	
      else if((Temp01>=1150)&&(Temp01<1170))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/295);
      }	
      else if((Temp01>=1170)&&(Temp01<1190))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/300);
      }
      else if((Temp01>=1190)&&(Temp01<1210))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/305);
      }	
      else if((Temp01>=1210)&&(Temp01<1230))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/310);
      }	
      else if((Temp01>=1230)&&(Temp01<1250))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/315);
      }	
      else if((Temp01>=1250)&&(Temp01<1270))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/320);
      }	
      else if((Temp01>=1270)&&(Temp01<1290))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/325);
      }
      else if((Temp01>=1290)&&(Temp01<1310))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/330);
      }	
      else if((Temp01>=1310)&&(Temp01<1330))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/335);
      }	
      else if((Temp01>=1330)&&(Temp01<1350))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/340);
      }	
      else if((Temp01>=1350)&&(Temp01<1370))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/345);
      }	
      else if((Temp01>=1370)&&(Temp01<1390))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/350);
      }
      else if((Temp01>=1390)&&(Temp01<1410))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/355);
      }	
      else if((Temp01>=1410)&&(Temp01<1430))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/360);
      }	
      else if((Temp01>=1430)&&(Temp01<1450))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/365);
      }	
      else if((Temp01>=1450)&&(Temp01<1470))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/370);
      }	
      else if((Temp01>=1470)&&(Temp01<1490))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/375);
      }
      else if((Temp01>=1490)&&(Temp01<1510))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/380);
      }					
      else if((Temp01>=1510)&&(Temp01<1530))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/385);
      }	
      else if((Temp01>=1530)&&(Temp01<1550))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/390);
      }	
      else if((Temp01>=1550)&&(Temp01<1570))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/395);
      }	
      else if((Temp01>=1570)&&(Temp01<1590))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/400);
      }
      else if((Temp01>=1590)&&(Temp01<1610))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/405);
      }	
      else if((Temp01>=1610)&&(Temp01<1630))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/410);
      }	
      else if((Temp01>=1630)&&(Temp01<1650))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/415);
      }	
      else if((Temp01>=1650)&&(Temp01<1670))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/420);
      }	
      else if((Temp01>=1670)&&(Temp01<1690))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/425);
      }
      else if((Temp01>=1690)&&(Temp01<1710))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/430);
      }					
      else if((Temp01>=1710)&&(Temp01<1730))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/435);
      }	
      else if((Temp01>=1730)&&(Temp01<1750))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/440);
      }	
      else if((Temp01>=1750)&&(Temp01<1770))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/445);
      }	
      else if((Temp01>=1770)&&(Temp01<1790))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/450);
      }
      else if((Temp01>=1790)&&(Temp01<1810))
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/455);
      }
      else
      {
        CalibrationVoltage = CalibrationVoltage - (unsigned int)(Temp01*AdjVoltage/460);
      }
    }
 
    if(AcqVolatage1<SetCorroV)                      //采集电压小于设定的腐蚀电压，正补偿
    {
      Temp02  = SetCorroV-AcqVolatage1;
      
      if((Temp02>=0)&&(Temp02<10))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/5);
      }
      else if((Temp02>=10)&&(Temp02<30))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/10);
      }
      else if((Temp02>=30)&&(Temp02<50))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/15);
      }	
      else if((Temp02>=50)&&(Temp02<70))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/20);
      }	
      else if((Temp02>=70)&&(Temp02<90))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/25);
      }	
      else if((Temp02>=90)&&(Temp02<110))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/30);
      }	
      else if((Temp02>=110)&&(Temp02<130))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/35);
      }
      else if((Temp02>=130)&&(Temp02<150))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/40);
      }	
      else if((Temp02>=150)&&(Temp02<170))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/45);
      }
      else if((Temp02>=170)&&(Temp02<190))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/50);
      }
      else if((Temp02>=190)&&(Temp02<210))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/55);
      }	
      else if((Temp02>=210)&&(Temp02<230))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/60);
      }
        else if((Temp02>=230)&&(Temp02<250))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/65);
      }
      else if((Temp02>=250)&&(Temp02<270))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/70);
      }
      else if((Temp02>=270)&&(Temp02<290))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/75);
      }	
      else if((Temp02>=290)&&(Temp02<310))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/80);
      }	
      else if((Temp02>=310)&&(Temp02<330))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/85);
      }	
      else if((Temp02>=330)&&(Temp02<350))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/90);
      }	
      else if((Temp02>=350)&&(Temp02<370))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/95);
      }	
      else if((Temp02>=370)&&(Temp02<390))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/100);
      }
      else if((Temp02>=390)&&(Temp02<410))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/105);
      }	
      else if((Temp02>=410)&&(Temp02<430))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/110);
      }
      else if((Temp02>=430)&&(Temp02<450))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/115);
      }	
      else if((Temp02>=450)&&(Temp02<470))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/120);
      }	
      else if((Temp02>=470)&&(Temp02<490))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/125);
      }	
      else if((Temp02>=490)&&(Temp02<510))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/130);
      }	
      else if((Temp02>=510)&&(Temp02<530))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/135);
      }
      else if((Temp02>=530)&&(Temp02<550))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/140);
      }	
      else if((Temp02>=550)&&(Temp02<570))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/145);
      }
      else if((Temp02>=570)&&(Temp02<590))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/150);
      }
      else if((Temp02>=590)&&(Temp02<610))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/155);
      }	
      else if((Temp02>=610)&&(Temp02<630))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/160);
      }
      else if((Temp02>=630)&&(Temp02<650))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/165);
      }
      else if((Temp02>=650)&&(Temp02<670))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/170);
      }
      else if((Temp02>=670)&&(Temp02<690))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/175);
      }	
      else if((Temp02>=690)&&(Temp02<710))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/180);
      }	
      else if((Temp02>=710)&&(Temp02<730))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/185);
      }	
      else if((Temp02>=730)&&(Temp02<750))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/190);
      }	
      else if((Temp02>=750)&&(Temp02<770))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/195);
      }	
      else if((Temp02>=770)&&(Temp02<790))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/200);
      }
      else if((Temp02>=790)&&(Temp02<810))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/205);
      }
      else if((Temp02>=810)&&(Temp02<830))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/210);
      }	
      else if((Temp02>=830)&&(Temp02<850))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/215);
      }	
      else if((Temp02>=850)&&(Temp02<870))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/220);
      }	
      else if((Temp02>=870)&&(Temp02<890))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/225);
      }
      else if((Temp02>=890)&&(Temp02<910))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/230);
      }	
      else if((Temp02>=910)&&(Temp02<930))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/235);
      }	
      else if((Temp02>=930)&&(Temp02<950))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/240);
      }	
      else if((Temp02>=950)&&(Temp02<970))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/245);
      }	
      else if((Temp02>=970)&&(Temp02<990))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/250);
      }
      else if((Temp02>=990)&&(Temp02<1010))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/255);
      }	
      else if((Temp02>=1010)&&(Temp02<1030))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/260);
      }	
      else if((Temp02>=1030)&&(Temp02<1050))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/265);
      }	
      else if((Temp02>=1050)&&(Temp02<1070))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/270);
      }	
      else if((Temp02>=1070)&&(Temp02<1090))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/275);
      }
      else if((Temp02>=1090)&&(Temp02<1110))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/280);
      }	
      else if((Temp02>=1110)&&(Temp02<1130))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/285);
      }	
      else if((Temp02>=1130)&&(Temp02<1150))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/290);
      }	
      else if((Temp02>=1150)&&(Temp02<1170))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/295);
      }	
      else if((Temp02>=1170)&&(Temp02<1190))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/300);
      }
      else if((Temp02>=1190)&&(Temp02<1210))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/305);
      }	
      else if((Temp02>=1210)&&(Temp02<1230))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/310);
      }	
      else if((Temp02>=1230)&&(Temp02<1250))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/315);
      }	
      else if((Temp02>=1250)&&(Temp02<1270))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/320);
      }	
      else if((Temp02>=1270)&&(Temp02<1290))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/325);
      }
      else if((Temp02>=1290)&&(Temp02<1310))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/330);
      }	
      else if((Temp02>=1310)&&(Temp02<1330))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/335);
      }	
      else if((Temp02>=1330)&&(Temp02<1350))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/340);
      }	
      else if((Temp02>=1350)&&(Temp02<1370))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/345);
      }	
      else if((Temp02>=1370)&&(Temp02<1390))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/350);
      }
      else if((Temp02>=1390)&&(Temp02<1410))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/355);
      }	
      else if((Temp02>=1410)&&(Temp02<1430))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/360);
      }	
      else if((Temp02>=1430)&&(Temp02<1450))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/365);
      }	
      else if((Temp02>=1450)&&(Temp02<1470))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/370);
      }	
      else if((Temp02>=1470)&&(Temp02<1490))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/375);
      }
      else if((Temp02>=1490)&&(Temp02<1510))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/380);
      }					
      else if((Temp02>=1510)&&(Temp02<1530))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/385);
      }	
      else if((Temp02>=1530)&&(Temp02<1550))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/390);
      }	
      else if((Temp02>=1550)&&(Temp02<1570))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/395);
      }	
      else if((Temp02>=1570)&&(Temp02<1590))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/400);
      }
      else if((Temp02>=1590)&&(Temp02<1610))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/405);
      }	
      else if((Temp02>=1610)&&(Temp02<1630))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/410);
      }	
      else if((Temp02>=1630)&&(Temp02<1650))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/415);
      }	
      else if((Temp02>=1650)&&(Temp02<1670))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/420);
      }	
      else if((Temp02>=1670)&&(Temp02<1690))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/425);
      }
      else if((Temp02>=1690)&&(Temp02<1710))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/430);
      }					
      else if((Temp02>=1710)&&(Temp02<1730))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/435);
      }	
      else if((Temp02>=1730)&&(Temp02<1750))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/440);
      }	
      else if((Temp02>=1750)&&(Temp02<1770))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/445);
      }	
      else if((Temp02>=1770)&&(Temp02<1790))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/450);
      }
      else if((Temp02>=1790)&&(Temp02<1810))
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/455);
      }
      else
      {
        CalibrationVoltage = CalibrationVoltage + (unsigned int)(Temp02*AdjVoltage/460);
      }
    }

    OffsetVoltage = SetVoltage - CalibrationVoltage;//计算补偿电压值(带符号)

    PWM_TO_DAC(5000,(unsigned int)(CalibrationVoltage *OutGain+(unsigned int)IA));
	  
			}
 			 AD_Refresh    = 0;	
     }
	 }
  
  //指示灯
//  if((AcqVolatage>500)&&(IA>0.05))//采集电压大于100MV
//  {

//    LED_OFF;
//  }
//  else
//  {
//     LED_ON;	
//  }
     if(AcqVolatage>500)   //  万博专用
		{

				 LED_ON;	
		}
		else
		{
				 LED_OFF;
		}	
 }
   OutCurrent = (unsigned int)(IA*100);       //放大10倍后的电流（触摸屏显示用）
}
void Delay10ms()		//@11.0592MHz
{
	unsigned char i, j;

	_nop_();
	_nop_();
	i = 144;
	j = 157;
	do
	{
		while (--j);
	} while (--i);
}
/*========================================================================
// 函数: DisableEEPROM(void)
// 描述: 禁止访问ISP/IAP.
// 参数: non.
// 返回: non.
// 版本: V1.0
//========================================================================
*/
void	DisableEEPROM(void)
{
	ISP_CONTR = 0;                              //关闭ISP功能
  ISP_CMD   = 0;                              //清除命令寄存器
  ISP_TRIG  = 0;                              //清除触发寄存器
  ISP_ADDRH = 0x80;                           //将地址设置到非ISP区域
  ISP_ADDRL = 0x00;
}
/*========================================================================
// 函数: void EEPROM_read_n(unsigned int EE_address,unsigned char *DataAddress,unsigned int number)
// 描述: 从指定EEPROM首地址读出n个字节放指定的缓冲.
// 参数: EE_address:  读出EEPROM的首地址.
//       DataAddress: 读出数据放缓冲的首地址.
//       number:      读出的字节长度.
// 返回: non.
// 版本: V1.0
//========================================================================
*/
void EEPROM_read_n(unsigned int EE_address,unsigned char *DataAddress,unsigned int number)
{
//	EA = 0;		                                  //禁止中断
	ISP_CONTR = (ISP_EN + ISP_WAIT_FREQUENCY);	//设置等待时间，允许ISP/ISP操作，送一次就够
	ISP_READ();									                //送字节读命令，命令不需改变时，不需重新送命令
	do
	{
		ISP_ADDRH = EE_address / 256;		          //送地址高字节（地址需要改变时才需重新送地址）
		ISP_ADDRL = EE_address % 256;		          //送地址低字节
		ISP_TRIG();				                        //先送5AH，再送A5H到ISP/ISP触发寄存器，每次都需要如此
                                              //送完A5H后，ISP/ISP命令立即被触发启动
                                              //CPU等待ISP完成后，才会继续执行程序。
		_nop_();
		*DataAddress = ISP_DATA;			            //读出的数据送往
		EE_address++;
		DataAddress++;
	}while(--number);

	DisableEEPROM();
//	EA = 1;		                                  //重新允许中断
}

/******************** 扇区擦除函数 *****************/
/*========================================================================
// 函数: void EEPROM_SectorErase(unsigned int EE_address)
// 描述: 把指定地址的EEPROM扇区擦除.
// 参数: EE_address:  要擦除的扇区EEPROM的地址.
// 返回: non.
// 版本: V1.0
//========================================================================
*/
void EEPROM_SectorErase(unsigned int EE_address)
{
//	EA = 0;														//禁止中断
																		//只有扇区擦除，没有字节擦除，512字节/扇区。
																		//扇区中任意一个字节地址都是扇区地址。
	ISP_ADDRH = EE_address / 256;			//送扇区地址高字节（地址需要改变时才需重新送地址）
	ISP_ADDRL = EE_address % 256;			//送扇区地址低字节
	ISP_CONTR = (ISP_EN + ISP_WAIT_FREQUENCY);	//设置等待时间，允许ISP/ISP操作，送一次就够
	ISP_ERASE();											//送扇区擦除命令，命令不需改变时，不需重新送命令
	ISP_TRIG();
	_nop_();
	DisableEEPROM();
//	EA = 1;														//重新允许中断
}
/*========================================================================
// 函数: void EEPROM_write_n(unsigned int EE_address,unsigned char *DataAddress,unsigned int number)
// 描述: 把缓冲的n个字节写入指定首地址的EEPROM.
// 参数: EE_address:  写入EEPROM的首地址.
//       DataAddress: 写入源数据的缓冲的首地址.
//       number:      写入的字节长度.
// 返回: non.
// 版本: V1.0
//========================================================================
*/
void EEPROM_write_n(unsigned int EE_address,unsigned char *DataAddress,unsigned int number)
{
//	EA = 0;																			//禁止中断

	ISP_CONTR = (ISP_EN + ISP_WAIT_FREQUENCY);	//设置等待时间，允许ISP/ISP操作，送一次就够
	ISP_WRITE();																//送字节写命令，命令不需改变时，不需重新送命令
	do
	{
		ISP_ADDRH = EE_address / 256;							//送地址高字节（地址需要改变时才需重新送地址）
		ISP_ADDRL = EE_address % 256;							//送地址低字节
		ISP_DATA  = *DataAddress;									//送数据到ISP_DATA，只有数据改变时才需重新送
		ISP_TRIG();
		_nop_();
		EE_address++;
		DataAddress++;
	}while(--number);

	DisableEEPROM();
//	EA = 1;																			//重新允许中断
}

/*========================================================================
// 函数: ADC_Init()
// 描述: ADC_Init初始化
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void ADC_Init()
{
  P1M0       = 0x00;                          //设置P1.4、P1.5、P1.6、P1.7为ADC口
  P1M1       = 0xF0;
  
  ADCCFG    |= 0x2F;                          //设置ADC时钟为系统时钟/2/16/Speed,设置结果右对齐
  ADC_CONTR  = 0x80;                          //使能ADC模块
  ADC_CONTR |= 0x40;                          //启动AD转换 
}
/*========================================================================
// 函数: unsigned int Get_ADC12bitResult(unsigned char channel)
// 描述: 查询法读一次ADC结果.
// 参数: channel: 选择要转换的ADC.
// 返回: 12位ADC结果.
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
unsigned int Get_ADC12bitResult(unsigned char channel)	//channel = 0~14
{
	ADC_RES  = 0;
	ADC_RESL = 0;

	ADC_CONTR = (ADC_CONTR & 0xe0) | 0x40 | channel; 	//start the ADC
	_nop_();
  _nop_();

	while((ADC_CONTR & 0x20) == 0);	//wait for ADC finish
	ADC_CONTR &= ~0x20;		          //清除ADC结束标志
	return	(((unsigned int)ADC_RES << 8) | ADC_RESL);
}
/*========================================================================
// 函数: unsigned int ADC_Average(__IO unsigned int *buff,unsigned int num,unsigned int threshold)
// 描述: 通过冒泡排序算法，去掉几个最大值和几个最小值，求剩下中间数的平均值.
// 参数: *buff：带处理的数组，num：数组长度，threshold：舍弃最大值、最小值个数
// 返回: 12位ADC结果.
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
unsigned int ADC_Average(unsigned int *buff,unsigned int num,unsigned int threshold)
{  
  //采集120个数据，然后进行2位过采样
	unsigned long sigma = 0;
  unsigned int i = 0,j = 0;
  unsigned int temp = 0;
	unsigned long ADR[15]; 
  
  for(j=0;j<num;j+=8)
	{
		temp=0;
		for(i=0;i<8;i++)
		{
			temp+=buff[j+i];
		}
		ADR[j/8]=temp/2;
	}
  
  for(i=0;i<15;i++)
	{
		for(j=0;j<15-1;j++)
		{
			if(ADR[j]<ADR[j+1])
			{
				temp = ADR[j];
				ADR[j]  = ADR[j+1];
				ADR[j+1]= temp;
			}
		} 
	}
	for(i=threshold;i<(15-threshold);i++)
	{
			sigma = sigma + ADR[i];
	}
	temp = sigma/(15-threshold*2);
	return(temp);
}
/*========================================================================
// 函数: void Read_ADC()
// 描述: 定时读取ADC的值，多次处理后取平均值.
// 参数: 无.
// 返回: 12位ADC结果.
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void Read_ADC()
{
  if(ADC_Cnt>=2)//2ms采集一次AD
  {
    ADC_Cnt = 0;
    
    ADC_EXT_Temp[Times] = Get_ADC12bitResult(4);//P1.4
    
    ADC0_Temp[Times]    = Get_ADC12bitResult(5);//P1.5
    ADC1_Temp[Times]    = Get_ADC12bitResult(6);//P1.6
    ADC2_Temp[Times]    = Get_ADC12bitResult(7);//P1.7
    
    Times ++;
    
    if(Times>=120)
    {
      Times = 0;
      
      //获取每个通道的AD值
      ADC_EXT_Value = ADC_Average(ADC_EXT_Temp,120,5);
      
      ADC0_Value    = ADC_Average(ADC0_Temp,120,5);
      ADC1_Value    = ADC_Average(ADC1_Temp,120,5);
      ADC2_Value    = ADC_Average(ADC2_Temp,120,5);
			
			//计算每个通道的实际电压
      
      EXT_Value   = ADC_EXT_Value*2498UL/16384;           //计算外部电压
      
      OutVoltage  = ADC0_Value*4.03*2498UL/DisSet;          //输出电压(负载两端电压)，根据实际情况修改
		  AcqVolatage = ADC1_Value*2498UL/DisSet*1.0-AcqError;      //采集电压

      IA = ((float)ADC2_Value*2498UL/DisSet/10.08)/2.0-CurrentError;      //实际输出电流,根据实际情况修改
      
      AD_Refresh = 1;
    }
  }
}
/*========================================================================
// 函数: UART1_Init()
// 描述: UART1_Init初始化
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void UART1_Init()
{
  SCON|= 0x50;
  T2L  = BRT;
  T2H  = BRT >> 8;
  AUXR|= 0x15;
  busy = 0;
  
  //串口切换
  P_SW1 = 0x00;                               //RXD/P3.0, TXD/P3.1
//  P_SW1 = 0x40;                               //RXD_2/P3.6, TXD_2/P3.7
//  P_SW1 = 0x80;                               //RXD_3/P1.6, TXD_3/P1.7
//  P_SW1 = 0xc0;                               //RXD_4/P4.3, TXD_4/P4.4
}
/*========================================================================
// 函数: void UartIsr() interrupt 4 using 1
// 描述: UART1中断函数
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void UartIsr() interrupt 4 using 1
{
  if (TI)
  {
    TI   = 0;
    busy = 0;
  }
  if (RI)
  {
    RI 			= 0;
//		Rx_Busy = 1;
    
		aRxBufferTemp = SBUF;
    
//    //上位机有数据发送，停止轮发
//    SendEN = 0;
//    UartCnt= 0;
        
		if(RX_5A_OK)
		{
			if(RX_A5_OK)
			{
				Rxbuff[Rx_count_UART1] = aRxBufferTemp;
				Rx_count_UART1 ++;
				
				if(Rx_count_UART1 == Rxbuff[0] + 1)			 //接收完成
				{              
					RX_5A_OK = 0;
					RX_A5_OK = 0;
					
					Rx_count_UART1 = 0;
					Uart1Ready_R 	 = 1;
//					Rx_Busy        = 0;
				}
			}
			else
			{
				if(aRxBufferTemp == 0xA5)
				{
					RX_A5_OK       = 1;
          Rx_count_UART1 = 0;
				}
				else
				{
					Rx_Busy = 0;
				}
			}
		}
		else 
		{
			if(aRxBufferTemp == 0x5A)
			{
				RX_5A_OK = 1;
			}
			else
			{
				Rx_Busy = 0;
			}
		}
  }
}
/*========================================================================
// 函数: void DataParsing()
// 描述: UART1串口数据解析
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void DataParsing(void)
{
	if(Uart1Ready_R==1)    //数据接收完成，处理接收到的数据
	{
		//按键返回
		if((Rxbuff[0]==0x06)&&(Rxbuff[1]==0x83)&&(Rxbuff[2]==0x00)&&(Rxbuff[3]==0x20)
		 &&(Rxbuff[4]==0x01)&&(Rxbuff[5]==0x00)&&(Rxbuff[6]==0x00))
		{
      //参数复位
      RunTime    = 0;       //运行时间
			Save_Cnt   = 0;
      SetVoltage = 2000;    //设置电压
      SetCorroV  = 650;     //腐蚀电压			
//      SetCorroV  = 920;     //腐蚀电压     //万博
      AdjVoltage = 3.0;     //调节电压
      CurrentError = 0;     //电流误差  
			AcqError   = 0;       //采集误差			
      OutSet     = 10000;
      DisSet     = 16146;   //显示设置
      OutGain    = 1.0000;  //输出设置
      Limitvoltage = 1600;        //极限电压		

		
		//参数掉电保存(直接调用函数)
    Save_Flag = 1;
    Parameter_Save();
		}
		
		//参数返回
		if((Rxbuff[0]==0x06)&&(Rxbuff[1]==0x83)&&(Rxbuff[2]==0x00))
		{
			if((Rxbuff[3]==0x04)&&(Rxbuff[4]==0x01))
			{
				SetVoltage = Rxbuff[5]*256 + Rxbuff[6]; //设置电压
        CalibrationVoltage = SetVoltage;
	    	//参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();				
			}
			if((Rxbuff[3]==0x05)&&(Rxbuff[4]==0x01))
			{
				SetCorroV = Rxbuff[5]*256 + Rxbuff[6]; 	//腐蚀电压
		    //参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();				
			}
			
      if((Rxbuff[3]==0x0E)&&(Rxbuff[4]==0x01))
			{
				OutSet     = Rxbuff[5]*256 + Rxbuff[6]; //输出设置
        OutGain    = (float)OutSet/10000;
		     //参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();				
			}
		
      if((Rxbuff[3]==0x0F)&&(Rxbuff[4]==0x01))
			{
				DisSet     = Rxbuff[5]*256 + Rxbuff[6]; //显示设置
		     //参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();				
			}
			if((Rxbuff[3]==0x10)&&(Rxbuff[4]==0x01))
			{
				CurrentError = (float)(Rxbuff[5]*256 + Rxbuff[6])/100; //电流误差
		    //参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();				
			} 
			if((Rxbuff[3]==0x11)&&(Rxbuff[4]==0x01))
			{
				AdjVoltage = (float)(Rxbuff[5]*256 + Rxbuff[6]);   //调节电压
	    	//参数掉电保存(直接调用函数)
       Save_Flag = 1;
       Parameter_Save();				
			}
			if((Rxbuff[3]==0x0D)&&(Rxbuff[4]==0x01))
			{
				AcqError = (float)(Rxbuff[5]*256 + Rxbuff[6])/10;     //采集误差
			   //参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();			
			}	
			
      if((Rxbuff[3]==0x12)&&(Rxbuff[4]==0x01))
			{
				Limitvoltage= Rxbuff[5]*256 + Rxbuff[6];  //新增--极限电压
			 //参数掉电保存(直接调用函数)
        Save_Flag = 1;
        Parameter_Save();	
			}			
	 }
 }	
				Uart1Ready_R = 0;	
}
/*========================================================================
// 函数: void UartSendData()
// 描述: UART1定时发送数据
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void UartSendData(void)
{
  //定时发送数据
	if(SendEN)
  {
    if(!busy)
    {
      busy = 1;
      if(!SendInit)
      {
        SendBuffer[0]  = 0x5A;
        SendBuffer[1]  = 0xA5;
        SendBuffer[2]  = 0X2F;                    //长度
        SendBuffer[3]  = 0X82;                    //命令
        SendBuffer[4]  = 0X00;                    //首地址H
        SendBuffer[5]  = 0X00;                    //首地址L
        //第一页参数显示
        SendBuffer[6]  = RunTime>>8;             //运行时间H
        SendBuffer[7]  = RunTime;                //运行时间L       
        SendBuffer[8]  = InVoltage>>8;           //输入电压H
        SendBuffer[9]  = InVoltage;              //输入电压L
        SendBuffer[10] = OutVoltage>>8;          //输出电压H
        SendBuffer[11] = OutVoltage;             //输出电压L
        SendBuffer[12] = OffsetVoltage>>8;       //补偿电压H
        SendBuffer[13] = OffsetVoltage;          //补偿电压L
        SendBuffer[14] = SetVoltage>>8;          //设置电压H
        SendBuffer[15] = SetVoltage;             //设置电压L
        SendBuffer[16] = SetCorroV>>8;           //腐蚀电压H
        SendBuffer[17] = SetCorroV;              //腐蚀电压L 
        SendBuffer[18] = AcqVolatage>>8;        //采集电压H
        SendBuffer[19] = AcqVolatage;           //采集电压L
        SendBuffer[20] = EXT_Value>>8;              //COM电压H
        SendBuffer[21] = EXT_Value;                 //COM电压L	

        //第二页参数显示
        SendBuffer[22] = ADC0_Value>>8;          //ADC0电压H
        SendBuffer[23] = ADC0_Value;             //ADC0电压L
        SendBuffer[24] = ADC1_Value>>8;          //ADC1电压H
        SendBuffer[25] = ADC1_Value;             //ADC1电压L
        SendBuffer[26] = ADC2_Value>>8;          //ADC2电压H
        SendBuffer[27] = ADC2_Value;             //ADC2电压L
        SendBuffer[28] = AcqVolatage1>>8;                   //实时采集误差H
        SendBuffer[29] = AcqVolatage1;                        //实时采集误差L
        SendBuffer[30] = SetCorroV >>8;                //初始误差H
        SendBuffer[31] = SetCorroV;                //初始误差L
        
        SendBuffer[32] = AcqError>>8;      //采集误差H(放大10倍显示)
        SendBuffer[33] = AcqError;          //采集误差L(放大10倍显示)       
        SendBuffer[34] = OutSet>>8;              //输出设置H
        SendBuffer[35] = OutSet;                 //输出设置L
        SendBuffer[36] = DisSet>>8;              //显示设置H
        SendBuffer[37] = DisSet;                 //显示设置L
        SendBuffer[38] = (unsigned int)(CurrentError*100)>>8;        //电流误差H
        SendBuffer[39] = (unsigned int)(CurrentError*100);           //电流误差L	
        SendBuffer[40] = (unsigned int)AdjVoltage>>8;          //调节电压H
        SendBuffer[41] = (unsigned int)AdjVoltage;             //调节电压L					
        SendBuffer[42] = Limitvoltage>>8;                            //新增-极限电压
        SendBuffer[43] = Limitvoltage;                               //新增-极限电压				
        SendBuffer[44] = Shut_Min >>8;                           //新增-重启时间
        SendBuffer[45] = Shut_Min ;                              //新增-重启时间				
        SendBuffer[46] = OutCurrent>>8;                           //输出电流H
        SendBuffer[47] = OutCurrent;                              //输出电流L					
				
				SendInit = 1;
				SentCnt	 = 0;
      }
      SBUF = SendBuffer[SentCnt++]; 
      if(SentCnt>47)
      {
        SendEN = 0;
      }
    }
  }
}
/*========================================================================
// 函数: Timer0_Init()
// 描述: Timer0初始化
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void Timer0_Init()
{
  TMOD|= 0x00;                                //模式0
  TL0  = 65536-FOSC/12/1000;
  TH0  = (65536-FOSC/12/1000)>>8;
  TR0  = 1;                                   //启动定时器
  ET0  = 1;                                   //使能定时器中断
}
/*========================================================================
// 函数: void TM0_Isr() interrupt 1 using 1
// 描述: Timer0中断函数
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void TM0_Isr() interrupt 1 using 1
{
  ADC_Cnt    ++;
  Cnt        ++;
  AcqInitCnt ++;
    

  /***  新增2019-11-14  ***/
  if(PWM_ON_EN)
  {
    Shut_MS ++;
    if(Shut_MS>=1000)
    {
      Shut_MS = 0;
      Shut_Sec ++;
      if(Shut_Sec>=60)
      {
        Shut_Sec = 0;
        Shut_Min ++;

      }
    }
  }
  
			if(Shut_Min>=180)//大于3小时，恢复工作
		{			
          PWM_ON_EN = 0;
          Shut_Hour = 0;
          Shut_Min  = 0;
          Shut_Sec  = 0;
          Shut_MS   = 0;
			}	
  
  if(++UartCnt>=200)
  {
    UartCnt = 0;
    SendEN  = 1;
    SendInit= 0;
  }

	//运行时间计时
	if(++Time_Cnt>=1000)    //1000ms
	{
    Time_Cnt = 0;
    Time_Sec ++;          //1s自动加1
    if(Time_Sec>=60)      //60s
    {
      Time_Sec = 0;
      Time_Min ++;      	//1min自动加1
      if(Time_Min>=60)  	//60s
      {
        Time_Min = 0;
        RunTime ++;
				
				Save_Cnt ++;
				if((Save_Cnt>0)&&((Save_Cnt%5)==0))
				{	
        Save_Flag = 1;    //运行参数1个小时保存一次
				Save_Cnt  = 0;	
				}	
      }
    }
	}
}
/*========================================================================
// 函数: PWM_Init()
// 描述: PWM初始化
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void PWM_Init()
{
  P_SW2   = 0x80;
  PWMCKS  = 0x00;                              //PWM时钟为系统时钟
  PWMC    = 8192;                              //设置PWM周期为8192个PWM时钟
  PWM5T1  = 0;                                 //在计数值为0地方输出低电平
  PWM5T2  = 8192;                              //在计数值为8192地方输出高电平
  PWM5CR  = 0x80;                              //使能PWM5输出
  P_SW2   = 0x00;

  PWMCR   = 0x80;                              //启动PWM模块
}
/*========================================================================
// 函数: void PWM_TO_DAC(unsigned int PowerVol,unsigned int OutVol)
// 描述: 根据输出源电压不同，输出不同电压。
// 参数: PowerVol:输出供电电压；OutVol：输出电压。
// 返回: 无
// 版本: VER1.0
// 日期: 2017-12-9
// 备注: 
//========================================================================
*/
void PWM_TO_DAC(unsigned int PowerVol,unsigned int OutVol)
{
  unsigned int PWM_Vlaue;
	if(OutVol>5500)
	{
		OutVol = 5500;
	}
  
  PWM_Vlaue = OutVol*8192UL/PowerVol/3;//单片机口输出电压跟负载电压比例为1:3
  
  P_SW2   = 0x80;
  PWM5T1  = 0;                    //在计数值为0地方输出低电平
  PWM5T2  = 8192-PWM_Vlaue;       //在计数值为8192地方输出高电平
  P_SW2   = 0x00;

}
/*========================================================================
// 函数: Parameter_Save()
// 描述: 参数保存
// 参数: 无
// 返回: 无
// 版本: VER1.0
// 日期: 2019-2-22
// 备注: 
//========================================================================
*/
void Parameter_Save(void)
{
  if(Save_Flag)
  {
		//参数掉电保存
		EEPROM_SectorErase(IAP_ADDRESS);

		TableWrite[0]  = RunTime>>8;			                      //运行时间H
		TableWrite[1]  = RunTime;				                        //运行时间L
		TableWrite[2]  = SetVoltage>>8;	                        //设置电压H
		TableWrite[3]  = SetVoltage;		                    	  //设置电压L
		TableWrite[4]  = SetCorroV>>8;		                      //腐蚀电压H
		TableWrite[5]  = SetCorroV;			                        //腐蚀电压L
		
    TableWrite[6]  = OutSet>>8;	                            //输出设置H
		TableWrite[7]  = OutSet;			                          //输出设置L
    TableWrite[8]  = DisSet>>8;	                            //显示设置H
		TableWrite[9]  = DisSet;			                          //显示设置L
		TableWrite[10] = (unsigned int)(CurrentError*100)>>8;   //电流误差H
		TableWrite[11] = (unsigned int)(CurrentError*100);		  //电流误差L		
		TableWrite[12] = (unsigned int)AdjVoltage>>8;	          //调节电压H
		TableWrite[13] = (unsigned int)AdjVoltage;		         //调节电压L 
		TableWrite[14] = (unsigned int)AcqError>>8;	           //采集误差H
		TableWrite[15] = (unsigned int)AcqError;		           //采集误差L
	
	  TableWrite[16] = Limitvoltage>>8;	                      //新增-极限电压
    TableWrite[17] = Limitvoltage;			                    //新增-极限电压
		
		EEPROM_write_n(IAP_ADDRESS,TableWrite,18);
    Save_Flag = 0;
  }
}