Temp/CHJ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
CHJ/user/Protocol/ReadWriteDataByCom.c
guishenking 6a749331db 差异
2026-03-20 21:19:53 +08:00

506 lines
16 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#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>
//}
Reference in New Issue View Git Blame Copy Permalink