SmartPDCode/control/PDU-AC-COMBINE/App/Modbus/BARE/port/port.c

/*
 * FreeModbus Libary: BARE Demo Application
 * Copyright (C) 2006 Christian Walter <wolti@sil.at>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * File: $Id$
 */

/* ----------------------- Modbus includes ----------------------------------*/
#include "mb.h"
#include "mbport.h"
#include "Main.h"
#include "string.h"
#include "At24cxx.h"
#include "ReadEeprom.h"
#include "gd32e230x_conf.h"
#include "Timer.h"
/* ----------------------- Defines ------------------------------------------*/
//输入寄存器
#define REG_INPUT_START  3000
#define REG_INPUT_NREGS  4

//保持寄存器
#define REG_HOLD_START   4000
#define REG_HOLD_NREGS   1500

//线圈
#define REG_COILS_START  0
#define REG_COILS_NREGS  4

//开关寄存器
#define REG_DISCRETE_START 1000
#define REG_DISCRETE_NREGS 4
/* ----------------------- Static variables ---------------------------------*/
static USHORT   usRegInputStart = REG_INPUT_START;
static USHORT   usRegInputBuf[REG_INPUT_NREGS];


static USHORT   usRegHoldStart = REG_HOLD_START;
static USHORT   usRegHoldBuf[REG_HOLD_NREGS];

static USHORT   usRegCoilsStart = REG_COILS_START;
static uint8_t  usRegCoilsBuf[REG_COILS_NREGS];

static USHORT   usRegDiscreteStart = REG_DISCRETE_START;
static uint8_t  usRegDiscreteBuf[REG_DISCRETE_NREGS];

extern unsigned long int Delay_Ms;
extern unsigned char detection_value;



/* ----------------------- Start implementation -----------------------------*/
//int
//main( void )
//{
//    eMBErrorCode    eStatus;

//    eStatus = eMBInit( MB_RTU, 0x0A, 0, 38400, MB_PAR_EVEN );

//    /* Enable the Modbus Protocol Stack. */
//    eStatus = eMBEnable(  );

//    for( ;; )
//    {
//        ( void )eMBPoll(  );

//        /* Here we simply count the number of poll cycles. */
//        usRegInputBuf[0]++;
//    }
//}
/****************************************************************************
* 名	  称：eMBRegInputCB
* 功    能：读取输入寄存器，对应功能码是 04 eMBFuncReadInputRegister
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*						usAddress: 寄存器地址
*						usNRegs: 要读取的寄存器个数
* 出口参数：
* 注	  意：上位机发来的 帧格式是: SlaveAddr(1 Byte)+FuncCode(1 Byte)
*								+StartAddrHiByte(1 Byte)+StartAddrLoByte(1 Byte)
*								+LenAddrHiByte(1 Byte)+LenAddrLoByte(1 Byte)+
*								+CRCAddrHiByte(1 Byte)+CRCAddrLoByte(1 Byte)
*							3 区
****************************************************************************/
eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;
		usAddress = usAddress - 1;
	
    if( ( usAddress >= REG_INPUT_START ) && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    {
        iRegIndex = ( int )( usAddress - usRegInputStart );
        while( usNRegs > 0 )
        {
            *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
            *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
            iRegIndex++;
            usNRegs--;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}
/****************************************************************************
* 名	  称：eMBRegHoldingCB
* 功    能：对应功能码有：06 写保持寄存器 eMBFuncWriteHoldingRegister
*													16 写多个保持寄存器 eMBFuncWriteMultipleHoldingRegister
*													03 读保持寄存器 eMBFuncReadHoldingRegister
*													23 读写多个保持寄存器 eMBFuncReadWriteMultipleHoldingRegister
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*						usAddress: 寄存器地址
*						usNRegs: 要读写的寄存器个数
*						eMode: 功能码
* 出口参数：
* 注	  意：4 区
****************************************************************************/
//unsigned int test1;
//unsigned int test2;
//unsigned int test3;
//unsigned int test4;
//unsigned long int test5=0x12345678;
//USHORT test6[20];
//unsigned char test[200]={0};
unsigned char Chal_num;
unsigned char WusNRegs;
unsigned int WiRegIndex;
unsigned int WeeiRegIndex;
unsigned char Eeprom_Wbuf[200];

extern ACDC_Wann_Read_Reg_t ACDC_Wann_All;
extern EE_ACDC_ThresVal_struct_ReadReg EE_ACDC_All_ThrVal;
extern EE_ACDC_State_All_Reg_En_t EE_ACDC_State_All_en;
extern ACDC_Over_Func_WriteReg 	ACDC_Over_AllWriteReg;
extern ACDC_Wann_Read_Reg_t ACDC_Wann_All;
extern AC_Ele_struct_ReadReg AC_Ele_ReadReg_All;

eMBErrorCode
eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;
		usAddress = usAddress - 1;
    if((usAddress >= REG_HOLD_START) && ((usAddress+usNRegs) <= (REG_HOLD_START + REG_HOLD_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegHoldStart);
				WiRegIndex = iRegIndex;
        switch(eMode)
        {
        case MB_REG_READ://读寄存器
						if((usAddress==Devid_ChalNumAddr)&&(usNRegs==Devid_ChalNumQua))				//读取设备类型和通道
							usRegHoldBuf[iRegIndex]= Devid_ChalNum;
						else if((usAddress>=AC_Sing_EleSmaAddr)&&(usAddress<=(AC_Sing_EleSmaAddr+AC_Sing_EleSmaQua)))//读取通道的参数
						{
							Chal_num = (usAddress-AC_Sing_EleSmaAddr)/12;												//获取是哪个通道的数据
							memcpy(&usRegHoldBuf[iRegIndex],&AC_Ele_ReadReg[Chal_num],usNRegs*2);
							if(usAddress==AC_Sing_EleSmaAddr)
									Start_Read_Flag = 1;
//							else if(usAddress==(AC_Sing_EleSmaAddr+12*(RelaySlaveChaNum-1)))
//									Start_Read_Flag = 0;
						}
						else if((usAddress>=AC_Sing_State_SmaAddr)&&(usAddress<=(AC_Sing_State_SmaAddr+AC_Sing_State_SmaQua)))//读取通道的状态
						{	
							Chal_num = (usAddress-AC_Sing_State_SmaAddr);                   		//获取是哪个通道的数据
							//增加其他的状态,开关状态在继电器动作的函数中进行跟新
							for(int chn = 0; chn < usNRegs; chn++)
							{
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Vol_Upthr_En 			= EE_ACDC_State_ReadReg[chn].ACDC_Vol_Upthr_En;
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Vol_Upthr_Warn 		= EE_ACDC_State_ReadReg[chn].ACDC_Vol_Upthr_Warn;
								
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Vol_Downthr_En 		= EE_ACDC_State_ReadReg[chn].ACDC_Vol_Downthr_En;
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Vol_Downthr_Warn 	= EE_ACDC_State_ReadReg[chn].ACDC_Vol_Downthr_Warn;
								
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Cur_Upthr_En 			= EE_ACDC_State_ReadReg[chn].ACDC_Cur_Upthr_En;
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Cur_Upthr_Warn 		= EE_ACDC_State_ReadReg[chn].ACDC_Cur_Upthr_Warn;
								
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Pow_Upthr_En 			= EE_ACDC_State_ReadReg[chn].ACDC_Pow_Upthr_En;
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Pow_Upthr_Warn 		= EE_ACDC_State_ReadReg[chn].ACDC_Pow_Upthr_Warn;
								
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Ele_Upthr_En 			= EE_ACDC_State_ReadReg[chn].ACDC_Ele_Upthr_En;
								EE_ACDC_State_ReadRegTrue[chn].ACDC_Ele_Upthr_Warn 		= EE_ACDC_State_ReadReg[chn].ACDC_Ele_Upthr_Warn;
							}
							memcpy(&usRegHoldBuf[iRegIndex],&EE_ACDC_State_ReadRegTrue[Chal_num],usNRegs*2);
						}else if((usAddress>=AC_Sing_Total_Consumer_Addr)&&(usAddress<=AC_Sing_Total_Consumer_Addr+AC_Sing_Total_ConsumerQua))
						{
							Chal_num = (usAddress-AC_Sing_Total_Consumer_Addr)/2;
							memcpy(&usRegHoldBuf[iRegIndex],&EE_ACDC_Total_Consum_Read_Reg[Chal_num],usNRegs*2);
						}else if((usAddress  >= AC_Sing_All_Chn_ConsumerAddr) &&(usAddress <= AC_Sing_All_Chn_ConsumerAddr + AC_Sing_All_Chn_ConsumerQua))
						{
							memcpy(&usRegHoldBuf[iRegIndex],&ACDC_Total_All_Chn_Read_Reg,usNRegs*2);
						}else if(usAddress == AC_Sing_Detection_Addr)
						{
							memcpy(&usRegHoldBuf[iRegIndex],&detection_value,usNRegs*2);
						}else if(usAddress == AC_Sing_All_Over_Func_Wann_Addr)
						{
							memcpy(&usRegHoldBuf[iRegIndex],&ACDC_Wann_All,2);
						}else if(usAddress >= AC_Sing_All_EleSmaAddr &&  usAddress  <= (AC_Sing_All_EleSmaAddr+AC_Sing_All_EleSmaQua))
						{
							Start_Read_Flag = 1;
							int base_addr = usAddress -AC_Sing_All_EleSmaAddr;
							uint32_t * base = (uint32_t *)(&AC_Ele_ReadReg_All);
							base += base_addr;
							memcpy(&usRegHoldBuf[iRegIndex],base,usNRegs*2);
						}
						
						
            while(usNRegs > 0)
            {
                *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] >> 8);
                *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF);
                iRegIndex++;
                usNRegs--;
            }
            break;
        case MB_REG_WRITE://写寄存器
						WusNRegs = usNRegs;
            while(usNRegs > 0)
            {
                usRegHoldBuf[iRegIndex] = *pucRegBuffer++ << 8;
                usRegHoldBuf[iRegIndex] |= *pucRegBuffer++;
                iRegIndex++;
                usNRegs--;
            }
						if((usAddress>=AC_Sing_Dela_OnSmaAddr)&&(usAddress<=AC_Sing_Dela_OnSmaAddr+AC_Sing_Dela_OnSmaQua))						//设置通道之间的开启延时
						{
								WeeiRegIndex = (int)(usAddress - AC_Sing_Dela_OnSmaAddr);
								Chal_num = (usAddress-AC_Sing_Dela_OnSmaAddr);                 					 					//设置哪个通道的延时
//								memcpy(&ACDC_Delay_WriteReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs);				//将接收的数据放入写结构体中
								memcpy(&EE_ACDC_Delay_ReadReg_On[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);		//将接收的数据放入读结构体中
								memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],WusNRegs*2);								 				//将数据由16进制转化为无符号数据存入数组 
								AT24CxxWrite(Eepr_AC_Sing_Dela_OnSmaAddr+WeeiRegIndex*2,Eeprom_Wbuf, WusNRegs*2); //将数据写入到eeprom中
							  memcpy(&Sort_Onbuf,&EE_ACDC_Delay_ReadReg_On,Eepr_AC_Sing_Dela_OnSmaQua);					//将数据进行排序，然后存入数组中，确保开关的时序
								Bubble_Sort(Sort_Onbuf,RelaySlaveChaNum);
//								AT24CxxRead(Eepr_AC_Sing_DelaSmaAddr+WusNRegs*2, test, Eepr_AC_Sing_DelaSmaQua);			//从eeprom中读出通道延时数据
//								memcpy(&EE_ACDC_Delay_ReadReg1,&test,Eepr_AC_Sing_DelaSmaQua);							//将数据拷贝到指定的结构体，可能需要注意大小端问题
						}
						else if((usAddress>=AC_Sing_Dela_OffSmaAddr)&&(usAddress<=AC_Sing_Dela_OffSmaAddr+AC_Sing_Dela_OffSmaQua))			//设置通道之间的关闭延时
						{
								WeeiRegIndex = (int)(usAddress - AC_Sing_Dela_OffSmaAddr);
								Chal_num = (usAddress-AC_Sing_Dela_OffSmaAddr);                 					 					//设置哪个通道的延时
//								memcpy(&ACDC_Delay_WriteReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs);				//将接收的数据放入写结构体中
								memcpy(&EE_ACDC_Delay_ReadReg_Off[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);		//将接收的数据放入读结构体中
								memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],WusNRegs*2);								 					//将数据由16进制转化为无符号数据存入数组 
								AT24CxxWrite(Eepr_AC_Sing_Dela_OffSmaAddr+WeeiRegIndex*2,Eeprom_Wbuf, WusNRegs*2); 	//将数据写入到eeprom中
								memcpy(&Sort_Offbuf,&EE_ACDC_Delay_ReadReg_Off,Eepr_AC_Sing_Dela_OffSmaQua);				//将数据进行排序，然后存入数组中
								Bubble_Sort(Sort_Offbuf,RelaySlaveChaNum);
//								AT24CxxRead(Eepr_AC_Sing_DelaSmaAddr+WusNRegs*2, test, Eepr_AC_Sing_DelaSmaQua);			//从eeprom中读出通道延时数据
//								memcpy(&EE_ACDC_Delay_ReadReg1,&test,Eepr_AC_Sing_DelaSmaQua);							//将数据拷贝到指定的结构体，可能需要注意大小端问题
						}
						else if((usAddress>=AC_Sing_State_SmaWAddr)&&(usAddress<=AC_Sing_State_SmaWAddr+AC_Sing_State_SmaWQua))//设置通道的状态
						{
							  WeeiRegIndex = (int)(usAddress - AC_Sing_State_SmaWAddr);
								Chal_num = (usAddress-AC_Sing_State_SmaWAddr);             					 				//设置哪个通道的状态
//								memcpy(&ACDC_State_WriteReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs);	//将接收的数据放入写结构体中
								memcpy(&EE_ACDC_State_ReadReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);//将接收的数据放入读结构体中
								for(int i =0; i < RelaySlaveChaNum;i++)
								{
									if(EE_ACDC_ThresVal_ReadReg[i].ACDC_V_TopThres <= THRESHOULD_JUDGMENT)
									{
										EE_ACDC_State_ReadReg[i].ACDC_Vol_Upthr_En = false;
									}
									if(EE_ACDC_ThresVal_ReadReg[i].ACDC_V_DownThres <= THRESHOULD_JUDGMENT)
									{
										EE_ACDC_State_ReadReg[i].ACDC_Vol_Downthr_En = false;
									}
									if(EE_ACDC_ThresVal_ReadReg[i].ACDC_I_TopThres <= THRESHOULD_JUDGMENT)
									{
										EE_ACDC_State_ReadReg[i].ACDC_Cur_Upthr_En = false;
									}
									if(EE_ACDC_ThresVal_ReadReg[i].ACDC_P_TopThres <= THRESHOULD_JUDGMENT)
									{
										EE_ACDC_State_ReadReg[i].ACDC_Pow_Upthr_En = false;
									}
									if(EE_ACDC_ThresVal_ReadReg[i].ACDC_E_TopThres <= THRESHOULD_JUDGMENT)
									{
										EE_ACDC_State_ReadReg[i].ACDC_Ele_Upthr_En = false;
									}
								}
								memcpy(&Eeprom_Wbuf,&EE_ACDC_State_ReadReg[Chal_num],WusNRegs*2);								   			//将数据由16进制转化为无符号数据存入数组 
								AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+WeeiRegIndex*2,Eeprom_Wbuf, WusNRegs*2); //将数据写入到eeprom中
							  if((WusNRegs==RelaySlaveChaNum)&&(EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State==true)&&(EE_ACDC_State_ReadReg[0].ACDC_ALLCha_On_State==true))//通过下发的通道数和开关状态可以判断为全开
								{
										All_On_Flag = 1;																										//全开标志置1
										All_Off_Flag = 0;	
										timer_enable(TIMER14);
										Delay_Ms_2 = 0;
								}
								else if((WusNRegs==RelaySlaveChaNum)&&(EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State==false)&&(EE_ACDC_State_ReadReg[0].ACDC_ALLCha_Off_State==true))//通过下发的通道数和开关状态可以判断为全关
								{
										All_Off_Flag = 1;																										//全关标志置1
										All_On_Flag = 0;	
										timer_enable(TIMER14);
										Delay_Ms_2 = 0;
								}
								else 
								{
#if SUPPORT_DETECTION
									
#if ((RelaySlaveChaNum  == 6) || ((RelaySlaveChaNum == 8) && SUPPORT_2_DETECTION))
									if((detection_value & 0x1) == 0)
									{
											uint8_t k = 0;
											for(k=0;k <(RelaySlaveChaNum)/2;k++)
												EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State = false;
									}
									if((detection_value & 0x2) == 0)
									{
											uint8_t k = 0;
											for(k=(RelaySlaveChaNum)/2;k <RelaySlaveChaNum;k++)
												EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State = false;
									}										
#else									
									if(detection_value != 0)
#endif
#endif
										//RelayState();	
										RelayState_ch(Chal_num);
								}
						}
						else if((usAddress>=AC_Sing_Thr_SmaAddr)&&(usAddress<=AC_Sing_Thr_SmaAddr+AC_Sing_Thr_SmaQua))//设置通道的阈值
						{
								WeeiRegIndex = (int)(usAddress - AC_Sing_Thr_SmaAddr);
								Chal_num = (usAddress-AC_Sing_Thr_SmaAddr)/16;              						 				//设置哪个通道的阈值
//								memcpy(&ACDC_ThresVal_WriteReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);		//将接收的数据放入写结构体中
								memcpy(&EE_ACDC_ThresVal_ReadReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);	//将接收的数据放入读结构体中
								
							
								if(EE_ACDC_ThresVal_ReadReg[Chal_num].ACDC_V_TopThres <= THRESHOULD_JUDGMENT)
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Vol_Upthr_En = false;
								}else
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Vol_Upthr_En = true;
								}
								if(EE_ACDC_ThresVal_ReadReg[Chal_num].ACDC_V_DownThres <= THRESHOULD_JUDGMENT)
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Vol_Downthr_En = false;
								}else
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Vol_Downthr_En = true;
								}
								if(EE_ACDC_ThresVal_ReadReg[Chal_num].ACDC_I_TopThres <= THRESHOULD_JUDGMENT)
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Cur_Upthr_En = false;
								}else
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Cur_Upthr_En = true;
								}
								if(EE_ACDC_ThresVal_ReadReg[Chal_num].ACDC_P_TopThres <= THRESHOULD_JUDGMENT)
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Pow_Upthr_En = false;
								}else
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Pow_Upthr_En = true;
								}
								if(EE_ACDC_ThresVal_ReadReg[Chal_num].ACDC_E_TopThres <= THRESHOULD_JUDGMENT)
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Ele_Upthr_En = false;
								}else
								{
									EE_ACDC_State_ReadReg[Chal_num].ACDC_Ele_Upthr_En = true;
								}
								memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],WusNRegs*2);								 		  //将数据由16进制转化为无符号数据存入数组 
								AT24CxxWrite(Eepr_AC_Sing_Thr_SmaAddr+WeeiRegIndex*2,Eeprom_Wbuf, WusNRegs*2);      //将数据写入到eeprom中
						}
						else if((usAddress>=AC_Sing_Coef_SmaAddr)&&(usAddress<=AC_Sing_Coef_SmaAddr+AC_Sing_Coef_SmaQua))//设置通道的系数
						{
								WeeiRegIndex = (int)(usAddress - AC_Sing_Coef_SmaAddr);
								Chal_num = (usAddress-AC_Sing_Coef_SmaAddr)/8;              								//设置哪个通道的系数
//								memcpy(&ACDC_Coef_WriteReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);		//将接收的数据放入写结构体中
								memcpy(&EE_ACDC_Coef_ReadReg[Chal_num],&usRegHoldBuf[WiRegIndex],WusNRegs*2);	//将接收的数据放入读结构体中
								memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],WusNRegs*2);								 	//将数据由16进制转化为无符号数据存入数组 
								AT24CxxWrite(Eepr_AC_Sing_Coef_SmaAddr+WeeiRegIndex*2,Eeprom_Wbuf, WusNRegs*2); //将数据写入到eeprom中
						}else if((usAddress>=AC_Sing_Channel_Func)&&(usAddress<=AC_Sing_Channel_Func+AC_Sing_Channel_FuncQua))
						{
							WeeiRegIndex = (int)(usAddress - AC_Sing_Channel_Func);
							memcpy(&ACDC_Over_WriteReg[WeeiRegIndex],&usRegHoldBuf[WiRegIndex],WusNRegs*2);
							memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
							AT24CxxWrite(Eepr_AC_Sing_Channel_Func_SmaAddr+WeeiRegIndex*2,Eeprom_Wbuf, WusNRegs*2);
						}else if(usAddress >= AC_Sing_Clear_Consumer && usAddress <= AC_Sing_Clear_Consumer+ AC_Sing_Clear_ConsumerQua)
						{
							//WeeiRegIndex = (int)(usAddress - AC_Sing_Clear_Consumer);
							Chal_num = usAddress-AC_Sing_Clear_Consumer;
							//AT24CxxRead(Eepr_AC_Sing_Total_Consumer_addr, Eeprom_Rbuf, Eepr_AC_Sing_Total_Consumer_SmaQua);
							
							uint16_t recive = 0;
							memcpy(&recive,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
							EE_ACDC_Consumer_Clear[Chal_num].flag = 1;
							EE_ACDC_Consumer_Clear[Chal_num].value = recive;
							consumer_clear_flag = 1;
						}else if(usAddress == AC_Sing_Clear_Consumer_all)
						{
							uint16_t recive = 0;
							memcpy(&recive,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
							consumer_clear_flag = 1;
							for(int i = 0; i < RelaySlaveChaNum;i++)
							{
								EE_ACDC_Consumer_Clear[i].flag = 1;
								EE_ACDC_Consumer_Clear[i].value = recive;
							}
						}else if(usAddress >= AC_Sing_All_Thr_SmaAddr && (usAddress <=(AC_Sing_All_Thr_SmaAddr + AC_Sing_All_Thr_SmaAddr_Qua)))
						{
							WeeiRegIndex = (int)(usAddress - AC_Sing_Thr_SmaAddr);
							//Chal_num = (usAddress-AC_Sing_All_Thr_SmaAddr)/16;  
							memcpy(&EE_ACDC_All_ThrVal,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
							
							if(EE_ACDC_All_ThrVal.ACDC_V_TopThres <= THRESHOULD_JUDGMENT)
							{
								EE_ACDC_State_All_en.ACDC_Vol_Upper_En = false;
							}else
							{
								EE_ACDC_State_All_en.ACDC_Vol_Upper_En = true;
							}
							if(EE_ACDC_All_ThrVal.ACDC_V_DownThres <= THRESHOULD_JUDGMENT)
							{
								EE_ACDC_State_All_en.ACDC_Vol_Lower_En= false;
							}else
							{
								EE_ACDC_State_All_en.ACDC_Vol_Lower_En= true;
							}
							if(EE_ACDC_All_ThrVal.ACDC_I_TopThres <= THRESHOULD_JUDGMENT)
							{
								EE_ACDC_State_All_en.ACDC_Current_Upper_En = false;
							}else
							{
								EE_ACDC_State_All_en.ACDC_Current_Upper_En= true;
							}
							if(EE_ACDC_All_ThrVal.ACDC_P_TopThres <= THRESHOULD_JUDGMENT)
							{
								EE_ACDC_State_All_en.ACDC_Power_Upper_En = false;
							}else
							{
								EE_ACDC_State_All_en.ACDC_Power_Upper_En = true;
							}
							if(EE_ACDC_All_ThrVal.ACDC_E_TopThres <= THRESHOULD_JUDGMENT)
							{
								EE_ACDC_State_All_en.ACDC_Consumer_Upper_En = false;
							}else
							{
								EE_ACDC_State_All_en.ACDC_Consumer_Upper_En= true;
							}
							memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
							AT24CxxWrite(Eepr_AC_Sing_All_Thr_SmaAddr,Eeprom_Wbuf, WusNRegs*2);
						}else if(usAddress == AC_Sing_All_Over_FuncAddr)
						{
							memcpy(&ACDC_Over_AllWriteReg,&usRegHoldBuf[WiRegIndex],2);
							memcpy(&Eeprom_Wbuf,&usRegHoldBuf[WiRegIndex],2);
							AT24CxxWrite(Eepr_AC_Sing_All_Over_SmaAddr,Eeprom_Wbuf,2);
						}
        }
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}

/****************************************************************************
* 名	  称：eMBRegCoilsCB
* 功    能：对应功能码有：01 读线圈 eMBFuncReadCoils
*													05 写线圈 eMBFuncWriteCoil
*													15 写多个线圈 eMBFuncWriteMultipleCoils
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*						usAddress: 线圈地址
*						usNCoils: 要读写的线圈个数
*						eMode: 功能码
* 出口参数：
* 注	  意：如继电器
*						0 区
****************************************************************************/
eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    UCHAR  ucStatus     = 0;
    UCHAR  ucBits       = 0;
    UCHAR  ucDisp       = 0;
		usAddress = usAddress - 1;
	
    if((usAddress >= REG_COILS_START) &&	((usAddress + usNCoils) <= (REG_COILS_START + REG_COILS_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegCoilsStart);
        switch(eMode)
        {
        case MB_REG_READ://读线圈
            while(usCoilGroups--)
            {
                ucDisp = 0;
                ucBits = 8;
                while((usNCoils--) != 0 && (ucBits--) != 0)
                {
                    ucStatus |= (usRegCoilsBuf[iRegIndex++] << (ucDisp++));
                }
                *pucRegBuffer++ = ucStatus;
            }
            break;
        case MB_REG_WRITE://写线圈
            while(usCoilGroups--)
            {
                ucStatus = *pucRegBuffer++;
                ucBits   = 8;
                while((usNCoils--) != 0 && (ucBits--) != 0)
                {
                    usRegCoilsBuf[iRegIndex++] = ucStatus & 0X01;
                    ucStatus >>= 1;
                }
            }
        }
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}
/****************************************************************************
* 名	  称：eMBRegDiscreteCB 
* 功    能：读取离散寄存器，对应功能码有：02 读离散寄存器 eMBFuncReadDiscreteInputs
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机   
*						usAddress: 寄存器地址
*						usNDiscrete: 要读取的寄存器个数
* 出口参数：
* 注	  意：1 区
****************************************************************************/
eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT usDiscreteGroups = ((usNDiscrete - 1) / 8 + 1);
    UCHAR  ucStatus     = 0;
    UCHAR  ucBits       = 0;
    UCHAR  ucDisp       = 0;
		usAddress = usAddress - 1;
	
    if((usAddress >= REG_DISCRETE_START) &&	((usAddress + usNDiscrete) <= (REG_DISCRETE_START + REG_DISCRETE_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegDiscreteStart);

				while(usDiscreteGroups--)
				{
						ucDisp = 0;
						ucBits = 8;
						while((usNDiscrete--) != 0 && (ucBits--) != 0)
						{
								if(usRegDiscreteBuf[iRegIndex])
								{
										ucStatus |= (1 << ucDisp);
								}
								ucDisp++;
						}
						*pucRegBuffer++ = ucStatus;
				}
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}