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

1003 lines
49 KiB
C
Raw Normal View History

NULL
2026-03-20 21:16:58 +08:00
#include "../main/SystemInclude.h"
const u16 ReadCode[] = {
CODE1, CODE2, CODE3, CODE4, CODE5, CODE6, CODE7, CODE8,
CODE9,CODE10,CODE11,CODE12,CODE13,CODE14,CODE15,CODE16 };
__HWSwitch_Union_TypeDef switchStatus;
/******************************************************************************/
NULL
2026-03-20 21:19:04 +08:00
void ReadMeterSystemData(void)
NULL
2026-03-20 21:16:58 +08:00
{
NULL
2026-03-20 21:19:04 +08:00
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();
NULL
2026-03-20 21:16:58 +08:00
NULL
2026-03-20 21:19:04 +08:00
#ifndef ENABLE_DEBUG_PIN
#pragma message("[undefined] ENABLE_DEBUG_PIN")
#elif(ENABLE_DEBUG_PIN)
switchStatus.Bit.DebugMode = ExternDebugInput();
#endif
#ifndef ENABLE_ZERO_CALIB_PIN
#pragma message("[undefined] ENABLE_ZERO_CALIB_PIN")
#elif(ENABLE_ZERO_CALIB_PIN)
switchStatus.Bit.ZeroCalib = ZeroCalibInput();
#endif
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_BPS: tempL.Word[0] = baudRate; break; // У׼ʱBPS
//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();
}
NULL
2026-03-20 21:16:58 +08:00
}
/******************************************************************************/
void ReadMeterInfo(void)
{
u16 I, K;
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
NULL
2026-03-20 21:19:04 +08:00
switch(MBBuf.StartAddr)
{
// case INT_SERIES_BASE:
// //ReadEEPROMByCom(SERIES_BASE, SERIES_DEPTH);
// for (I = 0; I < SERIES_DEPTH; I++) MBBuf.RxPointer[MBBuf.Index++] = meterSN[SERIES_DEPTH-I-1] ;return;
// continue; //0x8000 // [Enable Read And Write]
NULL
2026-03-20 21:16:58 +08:00
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;
NULL
2026-03-20 21:19:04 +08:00
case INT_TIME_BASE: ReadTimeBase(); continue; //0x8006 [Enable Read And Write]
NULL
2026-03-20 21:16:58 +08:00
case INT_CURVE_NUM:
NULL
2026-03-20 21:19:04 +08:00
#ifndef ENABLE_ONE_TABLE
#pragma message("[undefined] ENABLE_ONE_TABLE")
#elif(ENABLE_ONE_TABLE)
calibType = ENABLE_ONE_TABLE_NAME;
#endif
NULL
2026-03-20 21:16:58 +08:00
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 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 ReadMeterBasicData(void)
{
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr & INT_METER_BASIC_MASK)
{
NULL
2026-03-20 21:19:04 +08:00
case INT_METER_BASIC: // 0x8500
NULL
2026-03-20 21:16:58 +08:00
if(MBBuf.StartAddr > INT_METER_BASIC_MAX) return;
NULL
2026-03-20 21:19:04 +08:00
ReadMultiByteFromEEPROM(BASIC_DATA_BASE + (MBBuf.StartAddr - INT_METER_BASIC)*2, &tempL.Byte[0], 2, PARA_EEPROM);
NULL
2026-03-20 21:16:58 +08:00
break;
default:
tempL.Word[0] = 0;
break;
}
CopyDataAndJudgeComplete();
}
}
/******************************************************************************/
NULL
2026-03-20 21:19:04 +08:00
void ReadMeterParameter(void)
NULL
2026-03-20 21:16:58 +08:00
{
while(MBBuf.ByteNumber > 1)
{
NULL
2026-03-20 21:19:04 +08:00
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr)
{
case INT_KEY_ID: tempL.DWord = securityID; MBBuf.DataByte = 4; break; //0x8200 Fixed Address write parameter ID Key 0x9600 [Disable Read]
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]
// parameter Address
// case INT_PROTOCOL 0x8210 // MODBUS Slaver Addr
case INT_SLAVER_ADDR: tempL.Word[0] = localAddress; break; // 0x8211 // MODBUS Slaver Addr
case INT_METER_FACTOR: tempL.Word[0] = MeterFactor; break; // 0x8212
case INT_GDCF: tempL.Word[0] = GDCFactor; break; // 0x8213
case INT_MAX_FLOW: tempL.DWord = maxFlowRate; MBBuf.DataByte = 4; break; // 0x8214
case INT_OFFSET_GAS: tempL.Word[0] = offsetGas; break; // 0x8216
case INT_OFFSET_AIR: tempL.Word[0] = offsetAir; break; // 0x8217
case INT_SAMPLE_PERIOD: tempL.Word[0] = factoryInterval; break; // 0x8218 factoryInterval
case INT_HISTORY_PERIOD: tempL.Word[0] = historyPeriod; break; // 0x8219
//--------------------------------------------------------------------------------------------
#ifndef ENABLE_ACCPULSE
#pragma message("[undefined] ENABLE_ACCPULSE")
#elif(ENABLE_ACCPULSE)
case INT_PULSE_UNIT: tempL.Word[0] = calibUnitPerPulse; break; // 0x821A
#endif
//--------------------------------------------------------------------------------------------
case INT_SENSOR_SN: ReadEEPROMByCom(SENSOR_SN_BASE, SENSOR_SN_DEPTH); return; //0x821D // 0x821D/0x821E/0x821F
case INT_TOTAL_ACC: ReadACCFRByCom(); break; // 0x8220-0x8225
case INT_CALIB_TA: tempL.Word[0] = calibTemperature; break; // 0x8226 //0x8226
//==========================================================================
#ifndef ENABLE_A_TYPE_FLOWRATE
#pragma message("[undefined] ENABLE_A_TYPE_FLOWRATE")
#elif(ENABLE_A_TYPE_FLOWRATE)
case INT_OFFSET_A_GAS: tempL.Word[0] = offsetGasA; break; // 0x8227
case INT_OFFSET_A_AIR: tempL.Word[0] = offsetAirA; break; // 0x8228
case INT_ATYPE_INDEX_GAIN: tempL.Word[0] = ATypeIndexGain; break; // 0x8229
case INT_GDCF_ATYPE: tempL.Word[0] = GDCFactorAType; break; // 0x8230
case INT_FR_SWITCH_POINT: tempL.DWord = switchFIndex; MBBuf.DataByte = 4; break; // 0x825D
//==========================================================================
#ifndef ENABLE_PLUG_IN_FLOWRATE
#pragma message("[undefined] ENABLE_PLUG_IN_FLOWRATE")
#elif(ENABLE_PLUG_IN_FLOWRATE)
case INT_CALIB_PIPE: tempL.Word[0] = calibDiameter; break; // 0x822C
case INT_WORK_PIPE: tempL.Word[0] = workDiameter; break; // 0x822D
#endif
//==========================================================================
#ifndef ENABLE_AUTO_CALIB_ATYPE_OFFSET
#pragma message("[undefined] ENABLE_AUTO_CALIB_ATYPE_OFFSET")
#elif(ENABLE_AUTO_CALIB_ATYPE_OFFSET)
case INT_AUTO_CALIB_ATYPE: tempL.Word[0] = autoCalibrateOffset; break;
case INT_USER_INIT_INDEX: tempL.Word[0] = userInitialIndex; break;
#endif
//==========================================================================
#endif
//==============================================================================
case INT_WORK_UNIT: tempL.Word[0] = flowUnit; break; // 0x822E
case INT_DIS_LANGUAGE: tempL.Word[0] = language; break; // 0x822F
case INT_ACC_OUT_BIT: tempL.Word[0] = uartDecimalPoint; break; // 0x8230
case INT_REVERSE_SCALE: tempL.Word[0] = reverseScale; break; // 0x8231
case INT_VHH_HIGH: tempL.Word[0] = VHHHigh; break; // 0x8232
case INT_VHH_ROOM: tempL.Word[0] = VHHRoom; break; // 0x8233
case INT_VHH_LOW: tempL.Word[0] = VHHLow; break; // 0x8234
case INT_NRH_HIGH: tempL.Word[0] = NRHHigh; break; // 0x8235
case INT_NRH_ROOM: tempL.Word[0] = NRHRoom; break; // 0x8236
case INT_NRH_LOW: tempL.Word[0] = NRHLow; break; // 0x8237
case INT_GCF_A: tempL.DWord = GCFCoefA; MBBuf.DataByte = 4; break; // 0x823B
case INT_GCF_B: tempL.Word[0] = GCFCoefB; break; // 0x823D
case INT_GCF_C: tempL.DWord = GCFCoefC; MBBuf.DataByte = 4; break; // 0x823E
case INT_RH_GAINRES: tempL.Word[0] = RhExtGainRes; break; // 0x8240
case INT_ZERO_SUPPRESSION: tempL.Word[0] = zeroSuppression; break; // 0x8244
case INT_STATIC_LOW_TA: tempL.Word[0] = staticLowTemperature; break; // 0x8245
case INT_STATIC_HIGH_TA: tempL.Word[0] = staticHighTemperature; break; // 0x8246
//---------------------------------------------------------------------
#ifndef ENABLE_ACCPULSE
#pragma message("[undefined] ENABLE_ACCPULSE")
#elif(ENABLE_ACCPULSE)
case INT_PULSE_COUNTER: tempL.DWord = pulseCounter; MBBuf.DataByte = 4; break; // 0x8247
#endif
//---------------------------------------------------------------------
//case INT_ATYPE_RC: tempL.Word[0] = ATypeRC; break; // 0x8249 //
//---------------------------------------------------------------------
#ifndef ENABLE_USE_ATYPE_DCP
#pragma message("[undefined] ENABLE_USE_ATYPE_DCP")
#elif(ENABLE_USE_ATYPE_DCP)
case INT_ATYPE_WIPER: tempL.Word[0] = ATypeWiper; break; // 0x824A //
#endif
//---------------------------------------------------------------------
#ifndef ENABLE_USE_CTYPE_DCP
#pragma message("[undefined] ENABLE_USE_CTYPE_DCP")
#elif(ENABLE_USE_CTYPE_DCP)
case INT_CTYPE_WIPER: tempL.Word[0] = CTypeWiper; break; // 0x824B //
#endif
//---------------------------------------------------------------------
//case INT_CTYPE_ADC: tempL.Word[0] = calCTypeADC; break; // 0x824C //
case INT_OFFSET_HIGH: tempL.Word[0] = OffsetHigh; break; // 0x824D //
case INT_OFFSET_LOW: tempL.Word[0] = OffsetLow; break; // 0x824E //
case INT_TRH_HIGH: tempL.Word[0] = RHHighTa; break; // 0x824F //
case INT_TRH_LOW: tempL.Word[0] = RHLowTa; break; // 0x8250 //
//case INT_MEMS_RATIO: tempL.Word[0] = MEMSRatio; break; // 0x8251 //
//=====================================================================
#ifndef ENABLE_EDM7791_ALL
#pragma message("[undefined] ENABLE_EDM7791_ALL")
#elif(ENABLE_EDM7791_ALL)
case INT_SYS_LCD: tempL.Word[0] = SysLcd; break; // 0x8252 //
#endif
//=====================================================================
#ifndef ENABLE_4_20MA_ALL
#pragma message("[undefined] ENABLE_4_20MA_ALL")
#elif(ENABLE_4_20MA_ALL)
case INT_SYS_CHIP: tempL.Word[0] = SysLoopChip; break; // 0x8253 //
#endif
case INT_TEMP_CORR: tempL.Word[0] = temperatureFactor; break; // 0x8254 //
//--------------------------------------------------------------------
#ifndef ENABLE_SAMPLE_GREATER_GAIN
#pragma message("[undefined] ENABLE_SAMPLE_GREATER_GAIN")
#elif(ENABLE_SAMPLE_GREATER_GAIN)
case INT_OFFSET_VDUGX_GAS: tempL.Word[0] = offsetGasGainx; break; // 0x8255 //
case INT_OFFSET_VDUGX_AIR: tempL.Word[0] = offsetAirGainx; break; // 0x8256 //
case INT_OFFSET_RGINX: tempL.Word[0] = offsetGCFX; break; // 0x8257 //
#endif
//--------------------------------------------------------------------
case INT_NRH_P50: tempL.Word[0] = P0RhHigh; break; // 0x8258 // P0RhLow
case INT_NRH_P0: tempL.Word[0] = P0RhLow; break; // 0x8259 // P0RhLow
//--------------------------------------------------------------------
#ifndef ENABLE_ADJUST_ADC_GAIN
#pragma message("[undefined] ENABLE_ADJUST_ADC_GAIN")
#elif(ENABLE_ADJUST_ADC_GAIN)
case INT_ADC_GAIN: tempL.Word[0] = adcGain; break; // 0x825A
#endif
//--------------------------------------------------------------------
case INT_RES_FACTOR: tempL.Word[0] = resFactor; break; // 0x825B //
case INT_BATTEST_PERIOD: tempL.Word[0] = batteryTestPeriod; break; // 0x825C //
//--------------------------------------------------------------------
#ifndef ENABLE_FLOW_GAIN
#pragma message("[undefined] ENABLE_FLOW_GAIN")
#elif(ENABLE_FLOW_GAIN)
case INT_CALIB_FR_GAIN: tempL.Word[0] = calibFlowGain; break; // 0x825F //
#endif
NULL
2026-03-20 21:16:58 +08:00
NULL
2026-03-20 21:19:04 +08:00
//--------------------------------------------------------------------
#ifndef ENABLE_TD_TU_SWITCH_CONTROL
#pragma message("[undefined] ENABLE_TD_TU_SWITCH_CONTROL")
#elif(ENABLE_TD_TU_SWITCH_CONTROL)
case INT_DIVHX_HIGH: tempL.Word[0] = DIVHHigh; break; // 0x8262
case INT_DIVHX_ROOM: tempL.Word[0] = DIVHRoom; break; // 0x8263
case INT_DIVHX_LOW: tempL.Word[0] = DIVHLow; break; // 0x8264
#endif
#ifndef ENABLE_SAMPLE_GREATER_GAIN
#pragma message("[undefined] ENABLE_SAMPLE_GREATER_GAIN")
#elif(ENABLE_SAMPLE_GREATER_GAIN)
case INT_VDUGX_HIGH: tempL.Word[0] = VDUGXHigh; break; // 0x8265
case INT_VDUGX_ROOM: tempL.Word[0] = VDUGXRoom; break; // 0x8266
case INT_VDUGX_LOW: tempL.Word[0] = VDUGXLow; break; // 0x8267
#endif
//--------------------------------------------------------------------
default:
if(MBBuf.StartAddr > INT_METER_PARA_MAX) return;
tempL.Word[0] = 0;
break;
NULL
2026-03-20 21:16:58 +08:00
}
NULL
2026-03-20 21:19:04 +08:00
CopyDataAndJudgeComplete();
NULL
2026-03-20 21:16:58 +08:00
}
}
/******************************************************************************/
void InternalReadParameterProtocol(void)
{
u16 I;
NULL
2026-03-20 21:19:04 +08:00
NULL
2026-03-20 21:16:58 +08:00
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr & 0xff00)
{
NULL
2026-03-20 21:19:04 +08:00
case INT_METER_CODE: ReadMeterSamplingData(); continue; // 0x8300
case INT_METER_INFO: ReadMeterInfo(); continue; // 0x8000
case INT_METER_PARA: ReadMeterParameter(); continue; // 0x8200
case INT_METER_SYS: ReadMeterSystemData(); continue; // 0x8400
case INT_METER_BASIC: ReadMeterBasicData(); continue; // 0x8500
NULL
2026-03-20 21:16:58 +08:00
default:
NULL
2026-03-20 21:19:04 +08:00
switch(MBBuf.StartAddr & 0xf000)
NULL
2026-03-20 21:16:58 +08:00
{
NULL
2026-03-20 21:19:04 +08:00
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);
}
NULL
2026-03-20 21:16:58 +08:00
NULL
2026-03-20 21:19:04 +08:00
#ifndef ENABLE_2ND_CURVE
#pragma message("[undefined] ENABLE_2ND_CURVE")
#elif(ENABLE_2ND_CURVE)
else if(calibType == INT_2ND_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;
return;
default:
tempL.Word[0] = 0;
break;
NULL
2026-03-20 21:16:58 +08:00
}
}
for(I=1; I<=MBBuf.DataByte; I++) MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[MBBuf.DataByte-I];
ModbusVariablePointerDec();
}
}
NULL
2026-03-20 21:19:04 +08:00
/******************************************************************************/
NULL
2026-03-20 21:16:58 +08:00
// write************************************************************************
void InternalWriteParameterProtocol(void)
{
NULL
2026-03-20 21:19:04 +08:00
MBBuf.DataByte = 0;
NULL
2026-03-20 21:16:58 +08:00
while(1)
{
if(ModbusVariablePointerProcess()) return;
NULL
2026-03-20 21:19:04 +08:00
// start next parameter
MBBuf.DataByte = 2;
if(MBBuf.StartAddr == INT_KEY_ID) //8200
{
FreeSetDWordCmdByCom(&securityID);
if(securityID == COM_PASSWORD2) securityID = COM_PASSWORD1;
else if(securityID == COM_PASSWORD3) securityID = COM_PASSWORD1;
continue;
}
if(securityID != COM_PASSWORD1)
{
MBBuf.BusError = SLAVE_DEVICE_FAILURE;
return;
}
NULL
2026-03-20 21:16:58 +08:00
IDvalidTime = 0;
NULL
2026-03-20 21:19:04 +08:00
switch(MBBuf.StartAddr)
{
//=====================================================================
// Fixed Address for product series
//=====================================================================
case INT_SERIES_BASE:
WriteEEPROMByCom(SERIES_BASE, SERIES_DEPTH); //0x8000 // [Enable Read And Write]
//unsigned char J;
//for (J = 0; J < SERIES_DEPTH; J++) meterSN[SERIES_DEPTH-J-1] = ReadByteFromEEPROM(SERIES_BASE + J, PARA_EEPROM);
ReadMultiByteFromEEPROM(SERIES_BASE, (u8 *)&meterSN1, SERIES_DEPTH, PARA_EEPROM);
#ifndef ENABLE_BLUETOOTH_BEACON
#pragma message("[undefined] ENABLE_BLUETOOTH_BEACON")
#elif(ENABLE_BLUETOOTH_BEACON)
SetSNasBleName();
#endif
break;
case INT_TIME_BASE: //0x8006 [Enable Read And Write]
disable_interrupts();
WriteTimeBase();
WriteAnHistoryData(0); // save set time
break;
//=====================================================================
// fixed Read Address
//=====================================================================
//case INT_KEY_ID: tempL.DWord = securityID; MBBuf.DataByte = 4; break; //0x8200 Fixed Address write parameter ID Key 0x9600 [Disable Read]
case INT_CURVE_TYPE:
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
//calibType = 0;
if(tempL.Word[0] == INTCMD_CTYPE_CURVE) {
calibType = INTCMD_CTYPE_CURVE;
}
#ifndef ENABLE_2ND_CURVE
#pragma message("[undefined] ENABLE_2ND_CURVE")
#elif(ENABLE_2ND_CURVE)
else if(tempL.Word[0] == INT_2ND_CURVE_CMD) calibType = INT_2ND_CURVE_CMD;
#endif
#ifndef ENABLE_3RD_CURVE
#pragma message("[undefined] ENABLE_3RD_CURVE")
#elif(ENABLE_3RD_CURVE)
else if(tempL.Word[0] == INT_3RD_CURVE_CMD) calibType = INT_3RD_CURVE_CMD;
#endif
else if(tempL.Word[0] == INTCMD_1ST_TABLE) calibType = INTCMD_1ST_TABLE;
else if(tempL.Word[0] == INTCMD_2ND_TABLE) calibType = INTCMD_2ND_TABLE;
//==============================================================================
else if(tempL.Word[0] == INTCMD_PRESET_OFFSET) PreCalibrationParameterWriting();
else if(tempL.Word[0] == INTCMD_CALIB_HTEMP) HighTemperatureParameterWriting();
else if(tempL.Word[0] == INTCMD_CALIB_LTEMP) LowTemperatureParameterWriting();
else MBBuf.BusError = SLAVE_DEVICE_FAILURE;
break; // 0x8202 select curve type
//=====================================================================
// Variable Address and system work parameter
//=====================================================================
//case INT_COMMAND: tempL.Word[0] = calibOperateTime; break; // 0x820D internal control start address [Disable Read]
// Variable Address: internal parameter and control
case INT_CONTROL: //internal control start address [Disable Read]
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
disable_interrupts();
if(tempL.Word[0] == INTCMD_USER_MODE)
{
EnterUserMode(); // user mode
#ifndef ENABLE_ZERO_CALIB_CMD
#pragma message("[undefined] ENABLE_ZERO_CALIB_CMD")
#elif(ENABLE_ZERO_CALIB_CMD)
tempL.Word[0] = 0;
tempL.Word[0] = WriteShortParameterToEEPROM(SYS_COMMAND, SYS_COMMAND_WIDTH);
#endif
tempL.Word[0] = INTCMD_USER_MODE;
}
else if(tempL.Word[0] == INTCMD_CALIB_MODE) EnterCalibMode(); // calibration mode
//------------------------------------------------------------------------
#if(ENABLE_ZERO_CALIB_CMD)
else if(tempL.Word[0] == INTCMD_ZERO_CALIB_MODE)
{
tempL.Word[0] = INTCMD_ZERO_CALIB_HEX;
tempL.Word[0] = WriteShortParameterToEEPROM(SYS_COMMAND, SYS_COMMAND_WIDTH);
if(tempL.Word[0] != INTCMD_ZERO_CALIB_HEX) break;
EnterZeroCalibMode(); // calibration mode
tempL.Word[0] = INTCMD_ZERO_CALIB_MODE;
}
#endif
//------------------------------------------------------------------------
else if(tempL.Word[0] == INTCMD_DEBUG_MODE) EnterDebugMode(); // debug mode
else if(tempL.Word[0] == INTCMD_BATTERY_MODE) EnterBatteryMode(); // battery mode
else if(tempL.Word[0] == INTCMD_GCF_TEST_MODE) EnterGcfTestMode(); // GCF <20><><EFBFBD><EFBFBD> mode
else if(tempL.Word[0] == INTCMD_SAVE_SETUP) SaveFactorySetting(); // Save the factory setting
else if(tempL.Word[0] == INTCMD_RESTORE) RestoreFactorySetting(); // Restore factory settings
else if(tempL.Word[0] == INTCMD_RESET_CORR) DefaultDevCoef(); // Restore
else tempL.Word[0] = 0 ;
CMDComPassword = tempL.Word[0];
enable_interrupts();
return ;
case INT_CLEAR_RECORD: // 0x820E clear data record: [Disable Read]
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
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();
return ;
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];
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);
return;
// parameter Address
//case INT_PROTOCOL 0x8210 //
case INT_SLAVER_ADDR: // 0x8211 MODBUS Slaver Addr
// if(ZeroCalibInput())
// {
// tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
// tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
// tempL.Byte[SLAVER_ADDR_CRC] = CRC8(tempL.Byte, SLAVER_ADDR_CRC);
// WriteMultiByteToEEPROM(SLAVER_ADDR, tempL.Byte, SLAVER_ADDR_WIDTH, FROCK_EEPROM);
// ReadMultiByteFromEEPROM(SLAVER_ADDR, tempL.Byte, SLAVER_ADDR_WIDTH, FROCK_EEPROM);
// localAddress = tempL.Byte[0];
// }
// else WriteWordByCom(&localAddress, SLAVER_ADDR, SLAVER_ADDR_WIDTH, SLAVER_ADDR_MAX, SLAVER_ADDR_MIN);
// break;
case INT_METER_FACTOR: WriteWordByCom(&MeterFactor, METER_FACTOR, METER_FACTOR_WIDTH, METER_PARAMETER_MAX, METER_PARAMETER_MIN); break;// 0x8212
case INT_MAX_FLOW: // 0x8214
//WriteDWordByCom(&maxFlowRate,MAX_FLOW, MAX_FLOW_WIDTH,GetFlowRate(MAX_INDEX-1, CTYPE_FR), 0);
WriteDWordByCom(&maxFlowRate, MAX_FLOW, MAX_FLOW_WIDTH, 0xFFFFFFFF, 0);
DefaultDevCoef();
break;
case INT_OFFSET_GAS:
WriteWordByCom(&offsetGas, OFFSET_GAS, OFFSET_GAS_WIDTH, OFFSET_MAX, OFFSET_MIN);
//sampleState.EnableRoughTest = 0;
break; // 0x8216
case INT_OFFSET_AIR:
WriteWordByCom(&offsetAir, OFFSET_AIR, OFFSET_AIR_WIDTH, OFFSET_MAX, OFFSET_MIN);
//sampleState.EnableRoughTest = 0;
break; // 0x8217
case INT_SAMPLE_PERIOD: WriteWordByCom(&factoryInterval, SAMPLE_PERIOD, SAMPLE_PERIOD_WIDTH, SAMPLE_PERIOD_MAX, SAMPLE_PERIOD_MIN); break; // 0x8218
case INT_HISTORY_PERIOD: WriteWordByCom(&historyPeriod, HISTORY_PERIOD, HISTORY_PERIOD_WIDTH, 720, 0); break; // 0x8219
//---------------------------------------------------------------------
#ifndef ENABLE_ACCPULSE
#pragma message("[undefined] ENABLE_ACCPULSE")
#elif(ENABLE_ACCPULSE)
case INT_PULSE_UNIT: // 0x821A
//WriteWordByCom(&calibUnitPerPulse, CALIB_PULSE, CALIB_PULSE_WIDTH, CALIB_PULSE_UNIT_MAX, 1);
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if((signed int)CMDComPassword > CALIB_PULSE_UNIT_MAX) break;
if((signed int)CMDComPassword < CALIB_PULSE_UNIT_MIN) break;
tempDev.Word[0] = CMDComPassword;
calibUnitPerPulse = (signed int)WriteParameterToEEPROM(CALIB_PULSE, CALIB_PULSE_WIDTH);
lastRemaining = 0;
Total[MIN_BIT] = 0;
break;
#endif
//---------------------------------------------------------------------
case INT_SENSOR_SN: WriteEEPROMByCom(SENSOR_SN_BASE, SENSOR_SN_DEPTH); break; // 0x821D/0x821E/0x821F
case INT_TOTAL_ACC: WriteACCFRByCom(); break; // 0x8220-0x8225
case INT_CALIB_TA: WriteWordByCom(&calibTemperature, CALIB_TEMPERATURE, CALIB_TEMPERATURE_WIDTH, CALIB_TEMPRETURE_MAX, CALIB_TEMPRETURE_MIN); break; //0x8226
//=====================================================================
#ifndef ENABLE_A_TYPE_FLOWRATE
#pragma message("[undefined] ENABLE_A_TYPE_FLOWRATE")
#elif(ENABLE_A_TYPE_FLOWRATE)
case INT_OFFSET_A_GAS: WriteWordByCom(&offsetGasA, OFFSET_A_GAS, OFFSET_A_GAS_WIDTH, OFFSET_A_MAX, OFFSET_A_MIN); break; // 0x8227
case INT_OFFSET_A_AIR: WriteWordByCom(&offsetAirA, OFFSET_A_AIR, OFFSET_A_AIR_WIDTH, OFFSET_A_MAX, OFFSET_A_MIN); break; // 8228 // 0x8227
case INT_ATYPE_INDEX_GAIN:
if(!currentMode.Bit.CalibMode) return;
WriteWordByCom(&ATypeIndexGain, ATYPE_INDEX_GAIN, ATYPE_INDEX_GAIN_WIDTH, ATYPE_INDEX_GAIN_MAX, ATYPE_INDEX_GAIN_MIN);
break;
case INT_GDCF_ATYPE: WriteWordByCom(&GDCFactorAType, GCF_ATYPE, GCF_ATYPE_WIDTH, GCF_PARAMETER_MAX, GCF_PARAMETER_MIN); break; // 0x822A
case INT_FR_SWITCH_POINT: WriteDWordByCom(&switchFIndex, SWITCH_FR, SWITCH_FR_WIDTH, SWITCH_FR_INDEX_MAX, SWITCH_FR_INDEX_MIN); break; // 0x825D // 0x8228
//==========================================================================
#ifndef ENABLE_PLUG_IN_FLOWRATE
#pragma message("[undefined] ENABLE_PLUG_IN_FLOWRATE")
#elif(ENABLE_PLUG_IN_FLOWRATE)
case INT_CALIB_PIPE: WriteWordByCom(&calibDiameter, CALIB_DIAMETER, CALIB_DIAMETER_WIDTH, 100, 25); break; //0x822C
case INT_WORK_PIPE: WriteWordByCom(&workDiameter, WORK_DIAMETER, WORK_DIAMETER_WIDTH, 5000, 25); break; //0x822D
#endif
//==========================================================================
#ifndef ENABLE_AUTO_CALIB_ATYPE_OFFSET
#pragma message("[undefined] ENABLE_AUTO_CALIB_ATYPE_OFFSET")
#elif(ENABLE_AUTO_CALIB_ATYPE_OFFSET)
case INT_AUTO_CALIB_ATYPE: WriteWordByCom(&autoCalibrateOffset, AUTO_OFFSET_CMD, AUTO_OFFSET_CMD_WIDTH,0xff, 0);
case INT_USER_INIT_INDEX: WriteWordByCom(&userInitialIndex, USER_INIT_INDEX, USER_INIT_INDEX_WIDTH, 20000, 0);
#endif
//=====================================================================
#endif
//=====================================================================
case INT_WORK_UNIT: //0x822E
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
//controlCammand = flowUnit;
if(tempL.Word[0] == flowUnit) break;
ConvertAllFlowRateAndSave(tempL.Word[0]);
break;
//=====================================================================
case INT_DIS_LANGUAGE: WriteWordByCom(&language, DIS_LANGUAGE, DIS_LANGUAGE_WIDTH, 2, 0); break; // 0x822F
case INT_ACC_OUT_BIT: WriteWordByCom(&uartDecimalPoint, COM_DECIMAL_POINT, COM_DECIMAL_POINT_WIDTH, 4, 3); break; // 0x8230
case INT_REVERSE_SCALE: WriteWordByCom(&reverseScale, REVERSE_SCALE, REVERSE_SCALE_WIDTH, REVERSE_SCALE_MAX, REVERSE_SCALE_MIN); break; // 0x8231
case INT_VHH_HIGH: WriteWordByCom(&VHHHigh, VHH_HIGH, VHH_HIGH_WIDTH, VHH_MAX, VHH_MIN); break; // 0x8232
case INT_VHH_ROOM: WriteWordByCom(&VHHRoom, VHH_ROOM, VHH_ROOM_WIDTH, VHH_MAX, VHH_MIN); break; // 0x8233
case INT_VHH_LOW: WriteWordByCom(&VHHLow, VHH_LOW, VHH_LOW_WIDTH, VHH_MAX, VHH_MIN); break; // 0x8234
case INT_NRH_HIGH: WriteWordByCom(&NRHHigh, NRH_HIGH, NRH_HIGH_WIDTH, NRH_MAX, NRH_MIN); break; // 0x8235
case INT_NRH_ROOM: WriteWordByCom(&NRHRoom, NRH_ROOM, NRH_ROOM_WIDTH, NRH_MAX, NRH_MIN); break; // 0x8236
case INT_NRH_LOW: WriteWordByCom(&NRHLow, NRH_LOW, NRH_LOW_WIDTH, NRH_MAX, NRH_MIN); break; // 0x8237
//*********************************************************************
case INT_GCF_A:
WriteDWordByCom((u32 *)&GCFCoefA, GCF_A, GCF_A_WIDTH, 0xffffffff, 0);
ComputeGCFFactor();
break; // 0x823B
case INT_GDCF:
case INT_GCF_B: WriteWordByCom((u16 *)&GDCFactor, GCF_B, GCF_B_WIDTH, GCF_PARAMETER_MAX, GCF_PARAMETER_MIN);
ComputeGCFFactor();
break; // 0x8213 // 0x823D
case INT_GCF_C:
WriteDWordByCom((u32 *)&GCFCoefC, GCF_C, GCF_C_WIDTH, 0xffffffff, 0);
ComputeGCFFactor();
break; // 0x823E
//*********************************************************************
case INT_RH_GAINRES: WriteWordByCom(&RhExtGainRes, RH_GAINRES, RH_GAINRES_WIDTH, RH_GAINRES_MAX, RH_GAINRES_MIN); break; // 0x8240
case INT_ZERO_SUPPRESSION: WriteWordByCom(&zeroSuppression, ZERO_SUPPRESSION, ZERO_SUPPRESSION_WIDTH, ZERO_SUPPRESSION_MAX, ZERO_SUPPRESSION_MIN); break; // 0x8244
case INT_STATIC_LOW_TA: WriteWordByCom(&staticLowTemperature, STATIC_LOW_TA, STATIC_LOW_TA_WIDTH, STATIC_LOW_TA_MAX, STATIC_LOW_TA_MIN); break; // 0x8245
case INT_STATIC_HIGH_TA: WriteWordByCom(&staticHighTemperature, STATIC_HIGH_TA, STATIC_HIGH_TA_WIDTH, STATIC_HIGH_TA_MAX, STATIC_HIGH_TA_MIN); break; // 0x8246
//case INT_PULSE_COUNTER: WriteWordByCom(&pulseCounter, PULSE_COUNTER, PULSE_COUNTER_WIDTH, 0xFFFFFFFF, 0); break; // 0x8247
//FY
// case INT_ATYPE_RC:
// if(!currentMode.Bit.CalibMode) return;
// WriteWordByCom(&ATypeRC, ATYPE_RC, ATYPE_RC_WIDTH, ATYPE_RC_MAX, ATYPE_RC_MIN);
// ComputRRRHRatio();
// break; // 0x8249 //
//=====================================================================
#ifndef ENABLE_USE_ATYPE_DCP
#pragma message("[undefined] ENABLE_USE_ATYPE_DCP")
#elif(ENABLE_USE_ATYPE_DCP)
case INT_ATYPE_WIPER:
if(!currentMode.Bit.CalibMode) return;
SetWordCmdByCom(&calibType);
if(calibType != 0xAA55)
{
if(calibType > ATYPE_WIPER_MAX) break;
tempL.Word[0] = calibType;
calibType = 0;
ATypeWiper = (u16)WriteShortParameterToEEPROM(ATYPE_WIPER, ATYPE_WIPER_WIDTH);
ComputRRRHRatio();
}
else
{
calibType = ('A'<<8)+'P';
MaxCTypeWiper = ATYPE_WIPER_MAX;
MinCTypeWiper = ATYPE_WIPER_MIN;
}
break; // 0x824A //
#endif
//=====================================================================
#ifndef ENABLE_USE_CTYPE_DCP
#pragma message("[undefined] ENABLE_USE_CTYPE_DCP")
#elif(ENABLE_USE_CTYPE_DCP)
case INT_CTYPE_WIPER:
if(!currentMode.Bit.CalibMode) return;
SetWordCmdByCom(&calibType);
if(calibType != 0xAA55)
{
if(calibType > CTYPE_WIPER_MAX) break;
tempL.Word[0] = calibType;
calibType = 0;
CTypeWiper = (u16)WriteShortParameterToEEPROM(CTYPE_WIPER, CTYPE_WIPER_WIDTH);
//ComputRRRHRatio();
}
else
{
calibType = ('C'<<8)+'P';
MaxCTypeWiper = CTYPE_WIPER_MAX;
MinCTypeWiper = CTYPE_WIPER_MIN;
}
//WriteWordByCom(&CTypeWiper, CTYPE_WIPER, CTYPE_WIPER_WIDTH, CTYPE_WIPER_MAX, CTYPE_WIPER_MIN);
//ComputRRRHRatio();
break; // 0x824B //
#endif
//=====================================================================
#ifndef ENABLE_EDM7791_ALL
#pragma message("[undefined] ENABLE_EDM7791_ALL")
#elif(ENABLE_EDM7791_ALL)
case INT_SYS_LCD: WriteWordByCom(&SysLcd, SYS_LCD, SYS_LCD_WIDTH, SYS_LCD_MAX, SYS_LCD_MIN); break; // 0x8252 //
#endif
//=====================================================================
#ifndef ENABLE_4_20MA_ALL
#pragma message("[undefined] ENABLE_4_20MA_ALL")
#elif(ENABLE_4_20MA_ALL)
case INT_SYS_CHIP: WriteWordByCom(&SysLoopChip, SYS_LOOP_CHIP, SYS_LOOP_CHIP_WIDTH, SYS_LOOP_CHIP_MAX, SYS_LOOP_CHIP_MIN); break; // 0x8253 //
#endif
//=====================================================================
case INT_TEMP_CORR: WriteWordByCom(&temperatureFactor, TEMP_FACTOR, TEMP_FACTOR_WIDTH, TEMP_FACTOR_MAX, TEMP_FACTOR_MIN); break; // 0x8254 //
//--------------------------------------------------------------------
#ifndef ENABLE_SAMPLE_GREATER_GAIN
#pragma message("[undefined] ENABLE_SAMPLE_GREATER_GAIN")
#elif(ENABLE_SAMPLE_GREATER_GAIN)
case INT_OFFSET_VDUGX_GAS: WriteWordByCom(&offsetGasGainx, OFFSET_GAS_VDUGX, OFFSET_GAS_VDUGX_WIDTH, 20000, 4000); break;// 0x8255 //
case INT_OFFSET_VDUGX_AIR: WriteWordByCom(&offsetAirGainx, OFFSET_AIR_VDUGX, OFFSET_AIR_VDUGX_WIDTH, 20000, 4000); break; // 0x8256 //
case INT_OFFSET_RGINX: WriteWordByCom(&offsetGCFX, OFFSET_GCFX, OFFSET_GCFX_WIDTH, 20000, 4000); break; // 0x8257 //
#endif
//--------------------------------------------------------------------------
#ifndef ENABLE_A_TYPE_FLOWRATE
#pragma message("[undefined] ENABLE_A_TYPE_FLOWRATE")
#elif(ENABLE_A_TYPE_FLOWRATE)
case INT_NRH_P50: WriteWordByCom(&P0RhHigh, P0_0_RH, P0_0_RH_WIDTH, 65535, 0); break; // 0x8258 // P0RhLow
case INT_NRH_P0: WriteWordByCom(&P0RhLow, P0_0_RH, P0_0_RH_WIDTH, 65535, 0); break; // 0x8259 // P0RhLow
#endif
//--------------------------------------------------------------------
case INT_RES_FACTOR: WriteWordByCom(&resFactor, RES_FACTOR, RES_FACTOR_WIDTH, RES_FACTOR_MAX, RES_FACTOR_MIN); break; // 0x825B
case INT_BATTEST_PERIOD: WriteWordByCom(&batteryTestPeriod, BATTEST_PERIOD, BATTEST_PERIOD_WIDTH, BATTEST_PERIOD_MAX, BATTEST_PERIOD_MIN); break; // 0x825C
//=====================================================================
#ifndef ENABLE_ADJUST_ADC_GAIN
#pragma message("[undefined] ENABLE_ADJUST_ADC_GAIN")
#elif(ENABLE_ADJUST_ADC_GAIN)
case INT_ADC_GAIN: WriteWordByCom(&adcGain, SD24_GAIN, SD24_GAIN_WIDTH, 128, 1); break; // 0x825A
#endif
//=====================================================================
#ifndef ENABLE_FLOW_GAIN
#pragma message("[undefined] ENABLE_FLOW_GAIN")
#elif(ENABLE_FLOW_GAIN)
case INT_CALIB_FR_GAIN: // 0x825F
SetWordCmdByCom(&CMDComPassword);
//if(JudgeFlowRateGain(CMDComPassword)) break;
tempL.Word[0] = CMDComPassword;
calibFlowGain = (u16)WriteShortParameterToEEPROM(FLOW_GAIN, FLOW_GAIN_WIDTH);
break;
#endif
//=====================================================================
//Update program
case INT_UPDATE_APP:
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if(CMDComPassword == (u16)UPGRADE_APP_CMD)
{
UPGRADECammand = (u16)UPGRADE_APP_CMD;
disable_interrupts();
ResetSystem();
while(1);
}
// else
// {
// disable_interrupts();
// UPGRADECammand = 0;
// if((u16)ReadParameterFromMemory(UPGRADE_APP, UPGRADE_APP_WIDTH, 0) != 0xAA55) return;
// BackupParameterToFlash();
// enable_interrupts();
// }
else if(CMDComPassword == (u16)END_UPGRADE_APP_CMD)
{
disable_interrupts();
UPGRADECammand = 0;
BackupParameterToFlash();
enable_interrupts();
}
break;
//=====================================================================
case INT_CURVE_NUM: // 0x8009 [Enable Read And Write] // max:20
#ifndef ENABLE_ONE_TABLE
#pragma message("[undefined] ENABLE_ONE_TABLE")
#elif(ENABLE_ONE_TABLE)
calibType = ENABLE_ONE_TABLE_NAME;
#endif
if(calibType == INTCMD_1ST_TABLE) WriteWordByCom(&curveTANum, TACURVE_NUM, TACURVE_NUM_WIDTH, CURVE_DATA_MAX, 3);
else if(calibType == INTCMD_2ND_TABLE) WriteWordByCom(&curveATypeNum, ATYPECURVE_NUM, ATYPECURVE_NUM_WIDTH, CURVE_DATA_MAX, 3);
break;
//=====================================================================
// for calibration data
//=====================================================================
default:
if((MBBuf.StartAddr >= INT_CURVE_NODE1) && (MBBuf.StartAddr <= INT_CURVE_NODE36))
{
WriteCurveByCom();//0x800A-0x8073
break;
}
tempL.Word[0] = 0;
MBBuf.DataByte = 2;
if((MBBuf.StartAddr & 0xF000) != INT_CALIB_1) //0xE000
{
MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
return;
}
if(calibType == INTCMD_CTYPE_CURVE)//8202->4354
{
WriteCalbrationDataByCom(CALI_DATA_ADDR, MAX_OPERATE_DEPTH);
//currentMode.Bit.CalibMode = 0;
EnterUserMode();
}
//------------------------------------------------------------------------
#ifndef ENABLE_2ND_CURVE
#pragma message("[undefined] ENABLE_2ND_CURVE")
#elif(ENABLE_2ND_CURVE)
else if(calibType == INT_2ND_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;
return;
}
}
}
u8 untempBuf[CALIB_WIDTH],untempBuf1[CALIB_WIDTH];
void InternalWriteParameterProtocolToFlash(void)
{
MBBuf.DataByte = 0;
while(1)
{
if(ModbusVariablePointerProcess()) return;
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr)
{
case INT_SERIES_BASE: // 0x8000 <20><><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD> SN ----------------------------------------------------------
{
//SN<53>ij<EFBFBD><C4B3><EFBFBD>Ϊ6<CEAA><36>Word
WriteWordByComToFlash(&meterSN1,WP_VENDER);//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>meterSN1,<2C><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
WriteWordByComToFlash(&meterSN2,WP_VENDER);//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>meterSN2,<2C><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
WriteWordByComToFlash(&meterSN3,WP_VENDER);//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>meterSN3,<2C><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
WriteWordByComToFlash(&meterSN4,WP_VENDER);//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>meterSN4,<2C><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
WriteWordByComToFlash(&meterSN5,WP_VENDER);//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>meterSN5,<2C><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
WriteWordByComToFlash(&meterSN6,WP_VENDER);//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>meterSN6,<2C><><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
}break;
case INT_TIME_BASE: /*0x8006 ----------------------------------------------*/
{
}break;
case INT_CURVE_TYPE:{ /*0x8202 select curve type ----------------------------------------------*/
tempL.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
tempL.Byte[0] = MBBuf.RxPointer[MBBuf.Index++];
if(tempL.Word[0] == INTCMD_CTYPE_CURVE) {calibType =INTCMD_CTYPE_CURVE;}/*0x4354*/
else if(tempL.Word[0] == INTCMD_ATYPE_CURVE){calibType =INTCMD_ATYPE_CURVE;}/*0x4154*/
else if(tempL.Word[0] == INTCMD_1ST_TABLE){calibType = INTCMD_1ST_TABLE; }/*0x4E31*/
else if(tempL.Word[0] == INTCMD_2ND_TABLE){calibType = INTCMD_2ND_TABLE; }/*0x4E32*/
else if(tempL.Word[0] == INTCMD_PRESET_OFFSET) /*0x5057 <20><><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB><EFBFBD><EFBFBD>*/
{
tempL.Word[0] = voltageDetected[NIDX];
// if(voltageDetected[IVHDX]<56000)tempL.Word[0] = voltageDetected[NIDX];//<2F>ӳ<EFBFBD><D3B3><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD> offsetGas offsetAir
// else tempL.Word[0] =voltageDetected[VRHX ];
offsetGas = tempL.Word[0];
//offsetAir = tempL.Word[0];
munWriteParams = WP_VENDER;
if(mucSaveParams != PARAMS_ING) mucSaveParams = PARAMS_READY;
}
else if(tempL.Word[0] == INTCMD_CALIB_HTEMP)/*0x4854*/{HighTemperatureParameterWriting();}//
else if(tempL.Word[0] == INTCMD_CALIB_LTEMP)/*0x4c54*/{LowTemperatureParameterWriting();} //
else MBBuf.BusError = SLAVE_DEVICE_FAILURE;
}break;
case INT_OFFSET_GAS:// 0x8216 <20><><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD> offsetGas ----------------------------------------------
WriteWordByComToFlash(&offsetGas,WP_VENDER);//offsetGas<61><73><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
break;
case INT_OFFSET_AIR:// 0x8217 <20><><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD> offsetAir ----------------------------------------------
WriteWordByComToFlash(&offsetAir,WP_VENDER);//offsetAir<69><72><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD><DAB8><EFBFBD>Flashʱ<68><CAB1>װ<EFBFBD><D7B0>
break;
default:// --------------------------------------------------------------------------------------------
//д<><D0B4>У׼<D0A3><D7BC><EFBFBD><EFBFBD>
// //MBBuf.StartAddr = 0x800A-0x8073 д<><D0B4>36<33><36><EFBFBD><EFBFBD>---------------------------
// if((MBBuf.StartAddr >= INT_CURVE_NODE1) && (MBBuf.StartAddr <= INT_CURVE_NODE36))
// {
// WriteCurveByCom();
// break;
// }
//MBBuf.StartAddr = 0xE000 -------------------------------------------
if((MBBuf.StartAddr & 0xF000) != INT_CALIB_1) { MBBuf.BusError = ILLEGAL_DATA_ADDRESS; return; }//!=0xE000ֱ<30><D6B1><EFBFBD>˳<EFBFBD>
if(calibType == INTCMD_CTYPE_CURVE) //8202->4354
{
memcpy(untempBuf, (void *)&MBBuf.RxPointer[MBBuf.Index], MBBuf.ByteNumber);
if(offsetAir)
FLASH_Write_Calib_Data_ToFlash(MBBuf.StartAddr-0xE000 ,untempBuf);
else FLASH_Write_Calib2_Data_ToFlash(MBBuf.StartAddr-0xE000 ,untempBuf);
ReadCalibDataFromFlash( MBBuf.StartAddr-0xE000 ,untempBuf1, MBBuf.ByteNumber );
if(memcmp(untempBuf,untempBuf1, MBBuf.ByteNumber))MBBuf.BusError = SLAVE_DEVICE_FAILURE;
NULL
2026-03-20 21:16:58 +08:00
NULL
2026-03-20 21:19:04 +08:00
return;//<2F><><EFBFBD><EFBFBD>д
NULL
2026-03-20 21:16:58 +08:00
}
NULL
2026-03-20 21:19:04 +08:00
else MBBuf.BusError = SLAVE_DEVICE_FAILURE;
disable_interrupts();
}
}
NULL
2026-03-20 21:16:58 +08:00
}
NULL
2026-03-20 21:19:04 +08:00
void InternalReadParameterProtocolInFlash(void)
{
switch(MBBuf.StartAddr & 0xff00)
{
case INT_METER_CODE: ReadMeterSamplingData(); break; // 0x8300
case INT_METER_INFO: ReadMeterInfo(); break; // 0x8000
case INT_METER_PARA: ReadMeterParameter(); break; // 0x8200
case INT_METER_SYS: ReadMeterSystemData(); break; // 0x8400
case INT_METER_BASIC: ReadMeterBasicData(); break; // 0x8500
default:
// disable_interrupts();
if((MBBuf.StartAddr & 0xF000) == 0xE000)
{
if(calibType == INTCMD_CTYPE_CURVE) //ReadCalbrationDataByCom(CALI_DATA_ADDR, MAX_OPERATE_DEPTH);
{
if(offsetAir)ReadCalibDataFromFlash( MBBuf.StartAddr-0xE000 ,&MBBuf.RxPointer[MBBuf.Index], MBBuf.ByteNumber );
else ReadCalib2DataFromFlash(MBBuf.StartAddr-0xE000 ,&MBBuf.RxPointer[MBBuf.Index], MBBuf.ByteNumber );
}
}
return;
}
}
Reference in New Issue Copy Permalink