CHJ/user/Protocol/ReadWriteDataByCom.c

#include "../main/SystemInclude.h"

u16 parameterState;

/******************************************************************************/
void ReadTimeBase(void)
{
  //===========================================================================
#ifndef ENABLE_EXT_RTC 
#pragma message("[undefined] ENABLE_EXT_RTC")
#elif(ENABLE_EXT_RTC)
  if(TestExtRTCReady()) ExtRTCTimeRead();
  else                  ReadCurrentTime();
#else
//  ReadCurrentTime();
#endif
  
  MBBuf.RxPointer[MBBuf.Index++] = timer[YEAR];
  MBBuf.RxPointer[MBBuf.Index++] = timer[MONTH];
  MBBuf.RxPointer[MBBuf.Index++] = timer[DATE];
  MBBuf.RxPointer[MBBuf.Index++] = timer[HOUR];
  MBBuf.RxPointer[MBBuf.Index++] = timer[MINUTE];
  MBBuf.RxPointer[MBBuf.Index++] = timer[SECOND]; 
  MBBuf.DataByte = 6;
  ModbusVariablePointerDec();
}

///******************************************************************************/
void WriteTimeBase(void)
{
  MBBuf.DataByte = 6;
  if(MBBuf.ByteNumber < 6)
  {
    MBBuf.ByteNumber = 0;
    MBBuf.BusError = ILLEGAL_DATA_VALUE;
    return;
  }
  
  timer[YEAR]   = MBBuf.RxPointer[MBBuf.Index++];
  timer[MONTH]  = MBBuf.RxPointer[MBBuf.Index++];
  timer[DATE]   = MBBuf.RxPointer[MBBuf.Index++];
  timer[HOUR]   = MBBuf.RxPointer[MBBuf.Index++];
  timer[MINUTE] = MBBuf.RxPointer[MBBuf.Index++];
  timer[SECOND] = MBBuf.RxPointer[MBBuf.Index++];
  
  //===========================================================================
#ifndef ENABLE_EXT_RTC 
#pragma message("[undefined] ENABLE_EXT_RTC")
#elif(ENABLE_EXT_RTC)
  if(TestExtRTCReady()) ExtRTCTimeSet();
#endif
}

///******************************************************************************/
u16 ReadSecond(void)
{
//  u16 newSecond = RTCHOUR;
//  
//  if(newSecond > 11) newSecond -= 12;
//  newSecond *= 60;
//  newSecond += (u16)RTCMIN;
//  newSecond *= 60;
//  newSecond += (u16)RTCSEC;
    
// return newSecond; 
	return 1;
}

///******************************************************************************/
//void SaveFactorySetting(void)                                                   // Save the factory setting
//{
//  u16 I;
//  u8 temp[64];
//  
//  for(I=0; I< SAVE_PARA_MAX; I++)
//  {
//    ReadMultiByteFromMemory(I*64, temp, 64, PARA_EEPROM);
//    WriteMultiByteToMemory(I*64, temp, 64, DATA_EEPROM);
//  }
//  
//  WriteaAnAlarmData(0);
//}

///******************************************************************************/
//void RestoreFactorySetting(void)  
//{
//  u16 I;
//  unsigned char temp[64];
//  
//  for(I=0; I< SAVE_PARA_MAX; I++)
//  {
//    ReadMultiByteFromMemory(I*64, temp, 64, DATA_EEPROM);
//    WriteMultiByteToMemory(I*64, temp, 64, PARA_EEPROM);
//  }
//  
//  SystemParameterInit();
//}

/******************************************************************************/
//<2F>DZ<EFBFBD><C7B1><EFBFBD>Ϣ
void ReadCalibFAC(void)
{
  tempL.Word[0] = 0x8000;   //FAC<41><43><EFBFBD><EFBFBD>0x8000 <20><>ʾУ׼<D0A3><D7BC><EFBFBD>ݴ洢<DDB4><E6B4A2>ʽΪ<CABD><CEAA><EFBFBD><EFBFBD><EFBFBD>洢<EFBFBD><E6B4A2>FL1 FM1 FH1 <20><><EFBFBD><EFBFBD>FL2 FM2 FH2 <20><>......

//------------------------------------------------------------------------------
	#ifndef ENABLE_ONE_CURVE 
	#pragma message("[undefined] ENABLE_ONE_CURVE")
	#elif(ENABLE_ONE_CURVE)  
		 calibType = INTCMD_CTYPE_CURVE;
	#endif	 
	
//------------------------------------------------------------------------------
  if(calibType == INTCMD_CTYPE_CURVE)        tempL.Word[0] |= CALIB_COMP_FAC;  
//------------------------------------------------------------------------------
	#ifndef ENABLE_2ND_CURVE 
	#pragma message("[undefined] ENABLE_2ND_CURVE")
	#elif(ENABLE_2ND_CURVE)
		else if(calibType == INT_2RD_CURVE_CMD)   tempL.Word[0] |= CALIB_COMP_FAC2; 
	#endif
	
//------------------------------------------------------------------------------
	#ifndef ENABLE_3RD_CURVE 
	#pragma message("[undefined] ENABLE_3RD_CURVE")
	#elif(ENABLE_3RD_CURVE)
		else if(calibType == INT_3RD_CURVE_CMD) tempL.Word[0] |= CALIB_COMP_FAC3; 
	#endif
	
//------------------------------------------------------------------------------
  else tempL.Word[0] = 0;

  curveMode |= 0x0005;
}

/******************************************************************************/
void ReadCalibDepth(void)
{
//------------------------------------------------------------------------------
#ifndef ENABLE_ONE_CURVE 
#pragma message("[undefined] ENABLE_ONE_CURVE")
#elif(ENABLE_ONE_CURVE)
  calibType = INTCMD_CTYPE_CURVE;
#endif
//------------------------------------------------------------------------------
    
  if(calibType == INTCMD_CTYPE_CURVE)   
  {
    tempL.Word[0] = CALIB_DEPTH; 
  }
//------------------------------------------------------------------------------
#ifndef ENABLE_2ND_CURVE 
#pragma message("[undefined] ENABLE_2ND_CURVE")
#elif(ENABLE_2ND_CURVE)
  else if(calibType == INT_2RD_CURVE_CMD)  tempL.Word[0] = CALIB_DEPTH2; 
#endif
	
//------------------------------------------------------------------------------
#ifndef ENABLE_3RD_CURVE 
#pragma message("[undefined] ENABLE_3RD_CURVE")
#elif(ENABLE_3RD_CURVE)
  else if(calibType == INT_3RD_CURVE_CMD)  tempL.Word[0] = CALIB_DEPTH3; 
#endif
//------------------------------------------------------------------------------
 else  tempL.Word[0] = 0; 

  curveMode |= 0x00a0;  
}

/******************************************************************************/
void ReadCalibWidth(void)
{
  tempL.Word[0] = CALIB_WIDTH; 
  curveMode |= 0xa500;  
}

//******************************************************************************/
//******************************************************************************/
void ReadCalbrationDataByCom(u16 calibAddr, u16 calibDepth)
{
  MBBuf.StartAddr &= 0xFFF;
  if((MBBuf.StartAddr  >= calibDepth) || (MBBuf.ByteNumber >  CALIB_WIDTH))
  {
    MBBuf.ByteNumber = 0;
    MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
    return;
  }
  
  MBBuf.StartAddr *= CALIB_WIDTH;
  MBBuf.StartAddr += calibAddr;
  
  disable_interrupts();
  ReadCalbrationDataFromMemory(MBBuf.StartAddr, &MBBuf.RxPointer[3], MBBuf.ByteNumber);
//  u8 tempBuf[CALIB_WIDTH];
//  ReadCalbrationDataFromMemory(MBBuf.StartAddr, tempBuf, MBBuf.ByteNumber);
//  memcpy(&MBBuf.RxPointer[3], tempBuf, MBBuf.ByteNumber);                   //<2F><><EFBFBD><EFBFBD> DMA
  enable_interrupts();

  // systemProcessing.Bit.WriteHandle = 1; 
  MBBuf.ByteNumber = 0;
}

/******************************************************************************/
void CheckWritingLegality(void) 
{  
  MBBuf.BusError = ACKNOWLEDGE;  
  if((securityID != 0x0000AA55) && (securityID != COM_PASSWORD1) && (securityID != COM_PASSWORD2)) {                                   
    parameterState = ABORD_OPERATION; 
    MBBuf.ByteNumber = 0;	            
    return;                           
  }        
	
  MBBuf.BusError = 0;                 
  IDvalidTime = 0;          
}

/******************************************************************************/
void WriteCalbrationDataByCom(u16 calibAddr, u16 calibDepth)
{   
	CheckWritingLegality();
  
  MBBuf.StartAddr &= 0xFFF;
  if((MBBuf.StartAddr  >= calibDepth) || (MBBuf.ByteNumber >  CALIB_WIDTH))
  {
    MBBuf.ByteNumber = 0;
    MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
    return;
  }
  
  disable_interrupts();
  //if(MBBuf.StartAddr == 0) WriteMeterBasicData();
  MBBuf.StartAddr *= CALIB_WIDTH;
  MBBuf.StartAddr += calibAddr;	
// u8 tempBuf[CALIB_WIDTH];	
// memcpy(tempBuf, (void *)&MBBuf.RxPointer[MBBuf.Index], MBBuf.ByteNumber); //<2F><><EFBFBD><EFBFBD> DMA
// WriteCalbrationDataToMemory(MBBuf.StartAddr, tempBuf, MBBuf.ByteNumber);
	
  WriteCalbrationDataToMemory(MBBuf.StartAddr, &MBBuf.RxPointer[MBBuf.Index], MBBuf.ByteNumber); 
  enable_interrupts();
  
  systemProcessing.Bit.WriteHandle = 1; 
  MBBuf.ByteNumber = 0;
}

//******************************************************************************/
void ReadFlashByCom(const unsigned char *RDAdr, u16 RDLen)
{
  u16 I;
  
  for(I=0; I<RDLen; I++)  MBBuf.RxPointer[MBBuf.Index++] = *(RDAdr+I); 
  
  MBBuf.DataByte = RDLen;
  ModbusVariablePointerDec();
}

///******************************************************************************/
//void ReadArrayByCom(unsigned char *RDAdr, u16 RDLen)
//{
//  u16 I;
//  
//  for(I=0; I<RDLen; I++)  MBBuf.RxPointer[MBBuf.Index++] = *(RDAdr+I); 
//  
//  MBBuf.DataByte = RDLen;
//  ModbusVariablePointerDec();
//}

///******************************************************************************/
//void ReadDByteByCom(u16 RDValue)
//{
//  tempL.DWord = RDValue;
//  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1]; 
//  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0]; 
//  MBBuf.DataByte = 2;
//  ModbusVariablePointerDec();
//}

///******************************************************************************/
//void ReadDWordByCom(u32 RDValue)
//{
//  tempL.DWord = RDValue;
//  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[3]; 
//  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[2]; 
//  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1]; 
//  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0]; 
//  MBBuf.DataByte = 4;
//  ModbusVariablePointerDec();
//}

///******************************************************************************/
//void WriteEEPROMByCom(u16 WRAdr, u16 WRLen)
//{
//  MBBuf.DataByte = WRLen;
//  if(MBBuf.ByteNumber < WRLen)
//  {
//    MBBuf.ByteNumber = 0;
//    MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
//    return;
//  }
//  
//  WriteMultiByteToMemory(WRAdr, &MBBuf.RxPointer[MBBuf.Index], WRLen, PARA_EEPROM);
//  MBBuf.Index += WRLen;
//}

/**************************************************************************************/
/**************************************************************************************/
void FreeWriteMultiByteParameterByCom(u8 *WRSource, u16 WRAddr, u16 WRLen)
{
  //---------------------------------------------------------------------------
  parameterState = ABORD_OPERATION;
  MBBuf.BusError = ILLEGAL_DATA_VALUE;
  //---------------------------------------------------------------------------
  MBBuf.DataByte = WRLen;
  if(MBBuf.ByteNumber < MBBuf.DataByte) 
  {
    MBBuf.ByteNumber = 0;
    return; 
  }
	
  //---------------------------------------------------------------------------
  MBBuf.BusError = 0;   

	WriteMultiByteToMemory(WRAddr, &MBBuf.RxPointer[MBBuf.Index], WRLen);
  MBBuf.Index += WRLen;
	
  //---------------------------------------------------------------------------
  parameterState = NEED_OPERATION;
  MBBuf.BusError = 0;
  //---------------------------------------------------------------------------
  // *WRSource = WriteMultiByteToMemory(WRAddr, WRLen);
	ReadMultiByteFromMemory(WRAddr, WRSource,WRLen);
}

/**************************************************************************************/
void WriteMultiByteParameterByCom(u8 *WRSource, u16 WRAddr, u16 WRLen)
{
	CheckWritingLegality();	
  FreeWriteMultiByteParameterByCom(WRSource, WRAddr, WRLen);
}
	
/******************************************************************************/
/******************************************************************************/
void FreeSetWordCmdByCom(u16 *WRSource)
{
  MBBuf.DataByte = 2;
  if(MBBuf.ByteNumber < MBBuf.DataByte) 
  {
    MBBuf.ByteNumber = 0;
    parameterState = ABORD_OPERATION;
    MBBuf.BusError = ILLEGAL_DATA_VALUE;
    return; 
  }
  
  parameterState = NEED_OPERATION;
  MBBuf.BusError = 0;
    
  tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
  tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
  
  *WRSource = tempL.Word[0]; 
}

/******************************************************************************/
void SetWordCmdByCom(u16 *WRSource)
{
  CheckWritingLegality();	
  FreeSetWordCmdByCom(WRSource);
}

/******************************************************************************/
void FreWriteWordByCom(u16 *WRSource, u16 WRAddr)
{
	u16 I;
	
  I = *WRSource;	
  FreeSetWordCmdByCom(WRSource);

  if(tempL.Word[0] == I) return;
	
  parameterState = NEED_OPERATION;
  *WRSource = WriteShortParameterToMemory(WRAddr);
}

/******************************************************************************/
void WriteWordByCom(u16 *WRSource, u16 WRAddr)
{
  CheckWritingLegality();	
	FreWriteWordByCom(WRSource, WRAddr);
}

/******************************************************************************/
/******************************************************************************/
void FreeSetDWordCmdByCom(u32 *WRSource)
{
  MBBuf.DataByte = 4;
  if(MBBuf.ByteNumber < MBBuf.DataByte) 
  {
    MBBuf.ByteNumber = 0;
    parameterState = ABORD_OPERATION;
    MBBuf.BusError = ILLEGAL_DATA_VALUE;
    return; 
  }
  
  parameterState = NEED_OPERATION;
  MBBuf.BusError = 0;
    
  tempDev.Byte[3] = MBBuf.RxPointer[MBBuf.Index++];
  tempDev.Byte[2] = MBBuf.RxPointer[MBBuf.Index++];
  tempDev.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
  tempDev.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
  
  *WRSource = tempDev.DWord[0];
}

/******************************************************************************/
void SetDWordCmdByCom(u32 *WRSource)
{
  CheckWritingLegality();	
  FreeSetDWordCmdByCom(WRSource);
}

/******************************************************************************/
void FreWriteDWordByCom(u32 *WRSource, u16 WRAddr)
{
	u32 I;
	
  I = *WRSource;	
  FreeSetDWordCmdByCom(WRSource);

  if(tempDev.DWord[0] == I) return;	
  parameterState = NEED_OPERATION;
	
  *WRSource = WriteLongParameterToMemory(WRAddr);
}

/******************************************************************************/
void WriteDWordByCom(u32 *WRSource, u16 WRAddr)
{
  CheckWritingLegality();	
	FreWriteDWordByCom(WRSource, WRAddr);
}

/******************************************************************************/
/******************************************************************************/
void FreeWriteWordValidDataByCom(u16 *WRSource, u16 WRAddr, u16 WRMax, u16 WRMin)
{
	u16 WRTarget;
  FreeSetWordCmdByCom(&WRTarget);
	     if(WRTarget > WRMax) return;
  else if(WRTarget < WRMin) return;
	else if(*WRSource == WRTarget) return;
	
  parameterState = NEED_OPERATION;
  *WRSource = WriteShortParameterToMemory(WRAddr);
}

/******************************************************************************/
void WriteWordValidDataByCom(u16 *WRSource, u16 WRAddr, u16 WRMax, u16 WRMin)
{
  CheckWritingLegality();
  FreeWriteWordValidDataByCom(WRSource, WRAddr, WRMax, WRMin);	
}

/******************************************************************************/
void FreeWriteDWordValidDataByCom(u32 *WRSource, u16 WRAddr, u32 WRMax, u32 WRMin)
{
	u32 WRTarget;
  FreeSetDWordCmdByCom(&WRTarget);
	     if(WRTarget > WRMax) return;
  else if(WRTarget < WRMin) return;
	else if(*WRSource == WRTarget) return;
	
  parameterState = NEED_OPERATION;
  *WRSource = WriteLongParameterToMemory(WRAddr);
}

/******************************************************************************/
void WriteDWordValidDataByCom(u32 *WRSource, u16 WRAddr, u32 WRMax, u32 WRMin)
{
  CheckWritingLegality();
  FreeWriteDWordValidDataByCom(WRSource, WRAddr, WRMax, WRMin);
}

///******************************************************************************/
////<2F><><EFBFBD><EFBFBD><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//void WriteMeterBasicData(void)
//{
//   u16 I,J=0;
//   unsigned char temp[ANX*2];
//  
//   for(I=0; I<ANX; I++)
//   {
//     temp[J++] = voltageDetected[I] & 0xFF;
//     temp[J++] = voltageDetected[I] >> 8;
//   }
//   WriteMultiByteToMemory(BASIC_DATA_BASE, temp, BASIC_DATA_BYTE_MAX, PARA_EEPROM);
//}


///**************************************************************************************************************************/
//void WriteWordByComToFlash(u16* word,u8 WriteParams)
//{
//	tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
//	tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
//	*word = tempL.Word[0];
//	MBBuf.BusError = 0;
//	munWriteParams = WriteParams;	//ָ<><D6B8><EFBFBD><EFBFBD>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD>Flash<73><68><EFBFBD><EFBFBD>
//	if(mucSaveParams != PARAMS_ING)		mucSaveParams = PARAMS_READY;//word <20><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
//}