Temp/CHJ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
90c3d919df92cbdb4d397a7f24499e02018e4975
CHJ/user/Protocol/InternalModbus.c

638 lines
24 KiB
C
Raw Normal View History

NULL
2026-03-20 21:16:58 +08:00
#include "../main/SystemInclude.h"
u16 UPGRADECammand;
const u16 ReadCode[] = {
CODE1, CODE2, CODE3, CODE4, CODE5, CODE6, CODE7, CODE8,
CODE9,CODE10,CODE11,CODE12,CODE13,CODE14,CODE15,CODE16 };
u16 voltageDetected[ANX];
u16 WordReg[INT_WORD_REG_MAX]; //WordReg[128];/
u32 DWordReg[INT_DWORD_REG_MAX]; // DWordReg[64];//
//const u16 WordDefault[INT_WORD_REG_MAX][3] = WORD_DEFAULT;
const u16 WordDefault[INT_WORD_REG_MAX][3] = {
REG_0X8210_VALUE, REG_0X8211_VALUE, REG_0X8212_VALUE, REG_0X8213_VALUE,
REG_0X8214_VALUE, REG_0X8215_VALUE, REG_0X8216_VALUE, REG_0X8217_VALUE,
REG_0X8218_VALUE, REG_0X8219_VALUE, REG_0X821A_VALUE, REG_0X821B_VALUE,
REG_0X821C_VALUE, REG_0X821D_VALUE, REG_0X821E_VALUE, REG_0X821F_VALUE,
REG_0X8220_VALUE, REG_0X8221_VALUE, REG_0X8222_VALUE, REG_0X8223_VALUE,
REG_0X8224_VALUE, REG_0X8225_VALUE, REG_0X8226_VALUE, REG_0X8227_VALUE,
REG_0X8228_VALUE, REG_0X8229_VALUE, REG_0X822A_VALUE, REG_0X822B_VALUE,
REG_0X822C_VALUE, REG_0X822D_VALUE, REG_0X822E_VALUE, REG_0X822F_VALUE,
REG_0X8230_VALUE, REG_0X8231_VALUE, REG_0X8232_VALUE, REG_0X8233_VALUE,
REG_0X8234_VALUE, REG_0X8235_VALUE, REG_0X8236_VALUE, REG_0X8237_VALUE,
REG_0X8238_VALUE, REG_0X8239_VALUE, REG_0X823A_VALUE, REG_0X823B_VALUE,
REG_0X823C_VALUE, REG_0X823D_VALUE, REG_0X823E_VALUE, REG_0X823F_VALUE,
REG_0X8240_VALUE, REG_0X8241_VALUE, REG_0X8242_VALUE, REG_0X8243_VALUE,
REG_0X8244_VALUE, REG_0X8245_VALUE, REG_0X8246_VALUE, REG_0X8247_VALUE,
REG_0X8248_VALUE, REG_0X8249_VALUE, REG_0X824A_VALUE, REG_0X824B_VALUE,
REG_0X824C_VALUE, REG_0X824D_VALUE, REG_0X824E_VALUE, REG_0X824F_VALUE,
REG_0X8250_VALUE, REG_0X8251_VALUE, REG_0X8252_VALUE, REG_0X8253_VALUE,
REG_0X8254_VALUE, REG_0X8255_VALUE, REG_0X8256_VALUE, REG_0X8257_VALUE,
REG_0X8258_VALUE, REG_0X8259_VALUE, REG_0X825A_VALUE, REG_0X825B_VALUE,
REG_0X825C_VALUE, REG_0X825D_VALUE, REG_0X825E_VALUE, REG_0X825F_VALUE,
REG_0X8260_VALUE, REG_0X8261_VALUE, REG_0X8262_VALUE, REG_0X8263_VALUE,
REG_0X8264_VALUE, REG_0X8265_VALUE, REG_0X8266_VALUE, REG_0X8267_VALUE,
REG_0X8268_VALUE, REG_0X8269_VALUE, REG_0X826A_VALUE, REG_0X826B_VALUE,
REG_0X826C_VALUE, REG_0X826D_VALUE, REG_0X826E_VALUE, REG_0X826F_VALUE,
REG_0X8270_VALUE, REG_0X8271_VALUE, REG_0X8272_VALUE, REG_0X8273_VALUE,
REG_0X8274_VALUE, REG_0X8275_VALUE, REG_0X8276_VALUE, REG_0X8277_VALUE,
REG_0X8278_VALUE, REG_0X8279_VALUE, REG_0X827A_VALUE, REG_0X827B_VALUE,
REG_0X827C_VALUE, REG_0X827D_VALUE, REG_0X827E_VALUE, REG_0X827F_VALUE
};
//const u32 DWordDefault[INT_DWORD_REG_MAX][3] = DWORD_DEFAULT;
const u32 DWordDefault[INT_DWORD_REG_MAX][3] = {
REG_0X8280_VALUE, REG_0X8282_VALUE, REG_0X8284_VALUE, REG_0X8286_VALUE,
REG_0X8288_VALUE, REG_0X828A_VALUE, REG_0X828C_VALUE, REG_0X828E_VALUE,
REG_0X8290_VALUE, REG_0X8292_VALUE, REG_0X8294_VALUE, REG_0X8296_VALUE,
REG_0X8298_VALUE, REG_0X829A_VALUE, REG_0X829C_VALUE, REG_0X829E_VALUE
};
__HWSwitch_Union_TypeDef switchStatus;
void CalibSystemOffset(void);
/******************************************************************************/
//0x8200 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵʩ<CAB5><CAA9><EFBFBD><EFBFBD>
__weak void InterCurveProcess(void){}
__weak void InterControlProcess(void){}
__weak void SaveFactorySetting(void){}
__weak void RestoreFactorySetting(void){}
__weak void DefaultDevCoef(void){}
__weak void InterClearProcess(void){}
/******************************************************************************/
__weak void CalibSystemOffset(void)
{
tempL.Word[0] = voltageDetected[VDUGX];
if(CMDComPassword == ('K'<<8)+'Q') offsetAir = WriteShortParameterToMemory(GET_WORD_ADDR(offsetAir)); //4B51
else if(CMDComPassword == ('J'<<8)+'Z') offsetGas = WriteShortParameterToMemory(GAS_OFFSET); //4A5A
}
/******************************************************************************/
//0x8400ȫ<30><C8AB><EFBFBD><EFBFBD>ȡ ϵͳu16<31><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>-----------------------------------------
void InternalShortParameterInit(void)
{
for( u32 I=0; I< INT_WORD_REG_MAX; I++ ) //max128
{
WordReg[I] = ReadShortParameterFromMemory(MEM_ADDR_WORD_REG_START+I*REG_WORD_WIDTH, WordDefault[I][DEFAULT]);
}
}
/******************************************************************************/
//0x8500ȫ<30><C8AB><EFBFBD><EFBFBD>ȡ ϵͳu32<33><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>-----------------------------------------
void InternalLongParameterInit(void)
{
for( u32 I=0; I<INT_DWORD_REG_MAX; I++ )//64
{
DWordReg[I] = ReadLongParameterFromMemory(MEM_ADDR_DWORD_REG_START+I*REG_DWORD_WIDTH, DWordDefault[I][DEFAULT]);
}
}
/******************************************************************************/
//0x8000 <20><><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ȡ(RAM)-----------------------------------------
void ReadMeterInfo(void)
{
u16 I, K;
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr)
{
case INT_SERIES_BASE1: tempL.Word[0] = meterSN1 ; break;
case INT_SERIES_BASE2: tempL.Word[0] = meterSN2 ; break;
case INT_SERIES_BASE3: tempL.Word[0] = meterSN3 ; break;
case INT_SERIES_BASE4: tempL.Word[0] = meterSN4 ; break;
case INT_SERIES_BASE5: tempL.Word[0] = meterSN5 ; break;
case INT_SERIES_BASE6: tempL.Word[0] = meterSN6 ; break;
case INT_TIME_BASE: ReadTimeBase(); continue; //0x8006 [Enable Read And Write]
case INT_CURVE_NUM:
if(calibType == INTCMD_1ST_TABLE) tempL.Word[0] = curveTANum;
else if(calibType == INTCMD_2ND_TABLE) tempL.Word[0] = curveATypeNum;
else tempL.Word[0] = 0;
break;
default:
tempL.Word[0] = 0;
if(MBBuf.StartAddr < INT_CURVE_NODE1) break;
else if(MBBuf.StartAddr > INT_METER_INFO_MAX) return;
else if(MBBuf.StartAddr > INT_CURVE_MAX) break;
K = MBBuf.StartAddr-INT_CURVE_NODE1;
I = K / INT_CURVE_WIDTH;
K = K - I*INT_CURVE_WIDTH;
if(calibType == INTCMD_1ST_TABLE)
{
tempL.DWord = calibTANode[I];
if(K == 0) MBBuf.DataByte = 4;
else if(K == 1) tempL.Word[0] = tempL.Word[1];
else if(K == 2) tempL.Word[0] = calibTAVal[I];
}
else if(calibType == INTCMD_2ND_TABLE)
{
tempL.DWord = ATypeNode[I];
if(K == 0) MBBuf.DataByte = 4;
else if(K == 1) tempL.Word[0] = tempL.Word[1];
else if(K == 2) tempL.Word[0] = ATypeVal[I];
}
break;
}
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
void ReadMeterSystemData(void)
{
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr)
{
case INT_SYS_STATE: tempL.Word[0] = currentMode.Word; break; // 0x8400
//case INT_SYS_MODE: tempL.Word[0] = currentMode.Word; break; // 0x8401
//case INT_HARD_STATE: SystemHardWaerAutoCheck(); tempL.Word[0] = syatemHardState; break; // 0x8402
case INT_SWTICH_STATE: //0x8403
// switchStatus.Bit.CalibMode = ExternCalibratinInput();
tempL.Word[0] = switchStatus.Word;
break;
case INT_SYSTEM_VOLTAGE: tempL.Word[0] = systemVoltage; break;
case INT_PRODUCT_MODEL: ReadFlashByCom(ProductModel, 12); continue;
case INT_BUILD_DATE: ReadFlashByCom(SoftBuildDate, 10); continue;
// case INT_PGA_SCALE // PGA<47>Ŵ<EFBFBD><C5B4><EFBFBD><EFBFBD><EFBFBD>
case INT_FR_PPM: tempL.Word[0] = temperatureFactor; break; // PPM
//case INT_CODE_COEFF: tempL.Word[0] = codeCoeff; break; // TR<54><EFBFBD>ϵ<EFBFBD><CFB5> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>ϵ<EFBFBD><CFB5>
//case INT_TA_DELTA: tempL.Word[0] = deltaTA; break; // MCU<43><EFBFBD><C2B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
//case INT_BL_FLOW
//case INT_DOP_VALUE: tempL.Word[0] = CTypeWiper; break; // <20><><EFBFBD>ֵ<EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//case INT_STD_TA: tempL.Word[0] = correctTA; break; // У׼ʱ<D7BC><CAB1><EFBFBD><EFBFBD><EFBFBD>¶ȼ<C2B6><C8BC><EFBFBD>
//case INT_DAC_ADJUST_OUT1: tempL.Word[0] = (('D'<<8)+'A'); break; // //
//case INT_DAC_ADJUST_OUT2: tempL.Word[0] = DACClibVoltageL; break; // //
//case INT_DAC_ADJUST_OUT3: tempL.Word[0] = DACClibVoltageM; break; // //
//case INT_DAC_ADJUST_OVER: tempL.Word[0] = DACClibVoltageH; break; // //
//case INT_ZERO_CALIB_COUNTER: tempL.Word[0] = (u16)(compareBaseCounter>>ONE_SECOND_TIME_SHIFT); break;
default:
if(MBBuf.StartAddr > INT_METER_SYS_MAX) return;
tempL.Word[0] = 0;
break;
}
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
void ReadMeterInternalParameter(void)
{
while(MBBuf.ByteNumber > 1) {
if( MBBuf.StartAddr < INT_METER_PARA) ReadMeterOperateResult();
else if( MBBuf.StartAddr < INT_METER_DWORD_PARA) ReadMeterParameter();
else ReadMeterDWordParameter();
}
}
/******************************************************************************/
//0x8200 <20><><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ȡ(RAM)-----------------------------------------
void ReadMeterOperateResult(void)
{
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr) {
case INT_CURVE_TYPE: tempL.Word[0] = calibType; break; // 0x8202 select curve type
case INT_RTC_SECOND: tempL.Word[0] = ReadSecond(); break;
case INT_CALIB_FAC: ReadCalibFAC(); break; // 0x820A // 2Byte [Disable Write]
case INT_CALIB_DEPTH: ReadCalibDepth(); break; // 0x820B // 2Byte [Disable Write]
case INT_CALIB_WIDTH: ReadCalibWidth(); break; // 0x820C // 2Byte [Disable Write]
case INT_CONTROL: tempL.Word[0] = CMDComPassword; break;
// case INT_CLEAR_RECORD 0x820E // clear data record: [Disable Read]
// case INT_TEST_OFFSET 0x820F // [Disable Read]
default:
if(MBBuf.StartAddr > INT_METER_OPERATE_MAX) return;
tempL.Word[0] = 0;
break;
}
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
//0x8300 <20><><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ȡ(RAM)-----------------------------------------
void ReadMeterSamplingData(void) //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>Ʋɼ<C6B2><C9BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr & INT_READ_CODE_MASK)
{
case INT_READ_CODE_BASE: // 0x8300
tempL.Word[0] = voltageDetected[ReadCode[MBBuf.StartAddr - INT_READ_CODE_BASE] & ANX_MASK];
#ifndef ENABLE_READ_CODE_INTO_CALIB
#pragma message("[undefined] ENABLE_READ_CODE_INTO_CALIB")
#elif(ENABLE_READ_CODE_INTO_CALIB)
EnterCalibMode();
#endif
break;
case INT_SAMPLING_BASE1: // 0x8310
case INT_SAMPLING_BASE2: // 0x8320
tempL.Word[0] = voltageDetected[(MBBuf.StartAddr - INT_SAMPLING_BASE1) & ANX_MASK];
break;
default:
if(MBBuf.StartAddr > INT_METER_CODE_MAX) return;
tempL.Word[0] = 0;
break;
}
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
void ReadMeterParameter(void)
{
u16 I;
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
I = MBBuf.StartAddr - INT_METER_PARA;
if(I < INT_WORD_REG_MAX) tempL.Word[0] = WordReg[I];
else if(MBBuf.StartAddr > INT_METER_PARA_MAX) {
MBBuf.ByteNumber = 0;
return;
}
else tempL.Word[0] = 0;
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
void ReadMeterDWordParameter(void)
{
u16 I;
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 4;
I = MBBuf.StartAddr - INT_METER_DWORD_PARA;
if(I < INT_DWORD_REG_MAX) tempL.DWord = DWordReg[I];
else if(MBBuf.StartAddr > INT_METER_DWORD_PARA_MAX) {
MBBuf.ByteNumber = 0;
return;
}
else tempL.DWord = 0;
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
//0x8600 <20><><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ȡ-----------------------------------------
void ReadMeterBasicData(void)
{
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr & INT_METER_BASIC_MASK)
{
case INT_METER_BASIC:
if(MBBuf.StartAddr > INT_METER_BASIC_MAX) return;
ReadMultiByteFromMemory(BASIC_DATA_BASE + (MBBuf.StartAddr - INT_METER_BASIC)*2, &tempL.Byte[0], 2);
break;
default:
tempL.Word[0] = 0;
break;
}
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
//0x8000-----------------------------------------
void WriteMeterInfo(void)
{
u16 I;
while(MBBuf.ByteNumber > 1)
{
switch(MBBuf.StartAddr & 0xff00) {
case INT_SERIES_BASE:
{
MBBuf.DataByte = 12;
if( MBBuf.ByteNumber < MBBuf.DataByte ){
MBBuf.BusError = ILLEGAL_DATA_VALUE;
return;
}
WriteMultiByteParameterByCom((u8 *)&meterSN1, SERIES_BASE, SERIES_DEPTH); //0x8000 // [Enable Read And Write]
#ifndef ENABLE_BLUETOOTH_BEACON
#pragma message("[undefined] ENABLE_BLUETOOTH_BEACON")
#elif(ENABLE_BLUETOOTH_BEACON)
SetSNasBleName();
#endif
}
break;
case INT_TIME_BASE:
disable_interrupts();
WriteTimeBase();
//WriteAnHistoryData(0); /0x8006 [Enable Read And Write]
break; // save set time
case INT_CURVE_NUM: // 0x8009 [Enable Read And Write] // max:20
if(calibType == INTCMD_1ST_TABLE) WriteWordByCom(&curveTANum, TACURVE_NUM);
else if(calibType == INTCMD_2ND_TABLE) WriteWordByCom(&curveATypeNum, ATYPECURVE_NUM);
break;
default:
if((MBBuf.StartAddr >= INT_CURVE_NODE1) && (MBBuf.StartAddr <= INT_CURVE_NODE36)) WriteCurveByCom();
break;
}
if(ModbusVariablePointerProcess()) return;
}
}
/******************************************************************************/
//0x8400-----------------------------------------
void WriteMeterSystemData(void)
{
}
/******************************************************************************/
//0x8200-----------------------------------------
void MeterInternalOperate(void)
{
while(MBBuf.ByteNumber > 1) {
if( MBBuf.StartAddr < INT_METER_PARA) MeterOperate();
else if( MBBuf.StartAddr < INT_METER_DWORD_PARA) WriteMeterParameter();
else WriteMeterDwordParameter();
}
}
/******************************************************************************/
//0x8200-----------------------------------------
void MeterOperate(void)
{
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr) {
case INT_KEY_ID:
FreeSetDWordCmdByCom(&securityID);
if(securityID == COM_PASSWORD2) securityID = COM_PASSWORD1;
else if(securityID == COM_PASSWORD3) securityID = COM_PASSWORD1;
if(securityID == COM_PASSWORD1) IDvalidTime = 0;
break;
case INT_TIME_BASE: // 0x8006 [Enable Read And Write]
disable_interrupts();
WriteTimeBase();
WriteAnHistoryData(0); // save set time
enable_interrupts();
break;
case INT_CURVE_TYPE:
//tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
//tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
SetWordCmdByCom(&tempL.Word[0]);
InterCurveProcess();
break; // 0x8202 select curve type
case INT_CONTROL: //internal control start address [Disable Read]
//tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
//tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
SetWordCmdByCom(&tempL.Word[0]);
InterControlProcess();
CMDComPassword = tempL.Word[0];
break;
case INT_CLEAR_RECORD: // 0x820E clear data record: [Disable Read]
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
InterClearProcess();
// if(tempL.Word[0] == ('B'<<8)+'J') ClearAlarmRecord();
// else if(tempL.Word[0] == ('L'<<8)+'S') ClearHistoryRecord();
// else if(tempL.Word[0] == ('R'<<8)+'Z') ClearDateRecord();
break;
case INT_TEST_OFFSET: // 0x820F [Disable Read]
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
CMDComPassword = tempL.Word[0];
CalibSystemOffset();
// tempL.Word[0] = voltageDetected[NIDX]; // ReadDataFromMovingAverage(NIDX);
// if(CMDComPassword == ('K'<<8)+'Q') offsetAir = WriteShortParameterToEEPROM(OFFSET_AIR, OFFSET_AIR_WIDTH);
// else if(CMDComPassword == ('J'<<8)+'Z') offsetGas = WriteShortParameterToEEPROM(OFFSET_GAS, OFFSET_GAS_WIDTH);
break;
default:
if(MBBuf.StartAddr > INT_METER_OPERATE_MAX) return;
break;
}
if(ModbusVariablePointerProcess()) return;
}
}
/******************************************************************************/
//<2F><><EFBFBD><EFBFBD>ַд<D6B7><D0B4>-----------------------------------------
void WriteMeterParameter(void)
{
u16 I;
MBBuf.DataByte = 0;
CheckWritingLegality();
while(1) {
if(ModbusVariablePointerProcess()) return;
if(MBBuf.StartAddr > INT_METER_PARA_MAX) return;
I = MBBuf.StartAddr - INT_METER_PARA; //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
if(I < INT_WORD_REG_MAX ) {
FreeWriteWordValidDataByCom(&WordReg[I], MEM_ADDR_WORD_REG_START+I*REG_WORD_WIDTH, WordDefault[I][MAX], WordDefault[I][MIN]);
}
else {
MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
return;
}
}
}
/******************************************************************************/
//0x8500 <20><><EFBFBD><EFBFBD>ַд<D6B7><D0B4>-----------------------------------------
void WriteMeterDwordParameter(void)
{
u16 I;
MBBuf.DataByte = 0;
CheckWritingLegality();
while(1) {
if(ModbusVariablePointerProcess()) return;
if(MBBuf.StartAddr > INT_METER_DWORD_PARA_MAX) return;
I = MBBuf.StartAddr - INT_METER_DWORD_PARA;
I &= INT_MASK;
if(I < INT_DWORD_REG_MAX ) {
FreeWriteDWordValidDataByCom(&DWordReg[I], MEM_ADDR_DWORD_REG_START+I*REG_DWORD_WIDTH, DWordDefault[I][MAX], DWordDefault[I][MIN]);
}
else {
MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
return;
}
}
}
/******************************************************************************/
//<2F><>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿ<EFBFBD>
/******************************************************************************/
// read************************************************************************
void InternalReadParameterProtocol(void)
{
u16 I;
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr & 0xff00)
{
case INT_METER_CODE: ReadMeterSamplingData(); break; // 0x8300
case INT_METER_INFO: ReadMeterInfo(); break; // 0x8000
case INT_METER_OPERATE: ReadMeterInternalParameter(); break; // 0x8200
case INT_METER_SYS: ReadMeterSystemData(); break; // 0x8400
case INT_METER_BASIC: ReadMeterBasicData(); break; // 0x8600
default:
switch(MBBuf.StartAddr & 0xF000)
{
case INT_METER_D000: // 0xD000-DF00
if(MBBuf.StartAddr == INT_UPDATE_APP) tempL.Word[0] = ('A'<<8)+'P'; //0xDF00
else tempL.Word[0] = 0;
break;
case INT_METER_E000:
//displayMode = NO_DIS_UPDATE;
if(calibType == INTCMD_CTYPE_CURVE) {
ReadCalbrationDataByCom(CALI_DATA_ADDR, MAX_OPERATE_DEPTH);
}
#ifndef ENABLE_2ND_CURVE
#pragma message("[undefined] ENABLE_2ND_CURVE")
#elif(ENABLE_2ND_CURVE)
else if(calibType == INT_2RD_CURVE_CMD) ReadCalbrationDataByCom(CALI_DATA2_ADDR, MAX_OPERATE_DEPTH2);
#endif
#ifndef ENABLE_3RD_CURVE
#pragma message("[undefined] ENABLE_3RD_CURVE")
#elif(ENABLE_3RD_CURVE)
else if(calibType == INT_3RD_CURVE_CMD ) {
ReadCalbrationDataByCom(CALI_DATA3_ADDR, MAX_OPERATE_DEPTH3);
}
#endif
else MBBuf.BusError = SLAVE_DEVICE_FAILURE;
MBBuf.ByteNumber = 0;
return;
default:
tempL.Word[0] = 0;
break;
}
}
for(I=1; I<=MBBuf.DataByte; I++) MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[MBBuf.DataByte-I];
ModbusVariablePointerDec();
}
}
// write************************************************************************
void InternalWriteParameterProtocol(void)
{
MBBuf.DataByte = 0;
//----------------------------------------------------------------------------
if(securityID == 0x0000AA55) securityID = 0;
while(1)
{
if(ModbusVariablePointerProcess()) return;
IDvalidTime = 0;
switch(MBBuf.StartAddr & 0xff00) {
case INT_METER_INFO: WriteMeterInfo(); break; // 0x8000
case INT_METER_OPERATE: MeterInternalOperate(); break; // 0x8200
case INT_METER_SYS: WriteMeterSystemData(); break; // 0x8400
//case INT_METER_BASIC: WriteMeterBasicData(); break; // 0x8600
default:
switch(MBBuf.StartAddr & 0xF000) {
case INT_METER_D000: // 0xD000-DF00
{
// if(MBBuf.StartAddr != INT_UPDATE_APP) return;//0xDF00
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if(CMDComPassword == (u16)UPGRADE_APP_CMD) { //0xAA55
UPGRADECammand = (u16)UPGRADE_APP_CMD;
tempL.Word[0] =UPGRADECammand ;
WriteShortParameterToMemory(UPGRADE_APP);//0xAA55 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>--------------------
disable_interrupts();
LHL_GPIO_DeInit();
NVIC_SystemReset();/* ϵͳ<CFB5><CDB3>λ */ // while(1); RESET_SYSTEM wait wactdog ? ---- ִ<><D6B4>boot loader
}else if(CMDComPassword == (u16)END_UPGRADE_APP_CMD) {
tempL.Word[0] =CMDComPassword ;
WriteShortParameterToMemory(UPGRADE_APP); //0xBB66 <20>˳<EFBFBD><CBB3><EFBFBD><EFBFBD><EFBFBD>-------------------
}
}break;
case INT_METER_E000:
if(calibType == INTCMD_CTYPE_CURVE) {
WriteCalbrationDataByCom(CALI_DATA_ADDR, MAX_OPERATE_DEPTH);
}
//------------------------------------------------------------------------
#ifndef ENABLE_2ND_CURVE
#pragma message("[undefined] ENABLE_2ND_CURVE")
#elif(ENABLE_2ND_CURVE)
else if(calibType == INT_2RD_CURVE_CMD) WriteCalbrationDataByCom(CALI_DATA2_ADDR, MAX_OPERATE_DEPTH2);
#endif
//------------------------------------------------------------------------
// #ifndef ENABLE_3RD_CURVE
// #pragma message("[undefined] ENABLE_3RD_CURVE")
// #elif(ENABLE_3RD_CURVE)
else if(calibType == INT_3RD_CURVE_CMD) WriteCalbrationDataByCom(CALI_DATA3_ADDR, MAX_OPERATE_DEPTH3);
// #endif
//------------------------------------------------------------------------
else MBBuf.BusError = SLAVE_DEVICE_FAILURE;
MBBuf.ByteNumber = 0;
return;
default: MBBuf.BusError = SLAVE_DEVICE_FAILURE;
MBBuf.ByteNumber = 0;
return;
}
}
}
}
/******************************************************************************/
Reference in New Issue Copy Permalink