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

783 lines
29 KiB
C
Raw Normal View History

NULL
2026-03-20 21:16:58 +08:00
#include "../main/SystemInclude.h"
u16 MBReg[USER_INX_MAX];
static u16 *DataPoint;//
const u8 MAPDefault[] = {
MAP1_DEFAULT, MAP2_DEFAULT, MAP3_DEFAULT, MAP4_DEFAULT, MAP5_DEFAULT,
MAP6_DEFAULT, MAP7_DEFAULT, MAP8_DEFAULT, MAP9_DEFAULT, MAP10_DEFAULT,
MAP11_DEFAULT, MAP12_DEFAULT, MAP13_DEFAULT, MAP14_DEFAULT, MAP15_DEFAULT,
MAP16_DEFAULT, MAP17_DEFAULT, MAP18_DEFAULT, MAP19_DEFAULT, MAP20_DEFAULT,
MAP21_DEFAULT, MAP22_DEFAULT, MAP23_DEFAULT, MAP24_DEFAULT, MAP25_DEFAULT,
MAP26_DEFAULT, MAP27_DEFAULT, MAP28_DEFAULT, MAP29_DEFAULT, MAP30_DEFAULT,
MAP31_DEFAULT, MAP32_DEFAULT, MAP33_DEFAULT, MAP34_DEFAULT, MAP35_DEFAULT,
MAP36_DEFAULT, MAP37_DEFAULT, MAP38_DEFAULT, MAP39_DEFAULT, MAP40_DEFAULT,
MAP41_DEFAULT, MAP42_DEFAULT, MAP43_DEFAULT, MAP44_DEFAULT, MAP45_DEFAULT,
MAP46_DEFAULT, MAP47_DEFAULT, MAP48_DEFAULT };
NULL
2026-03-20 21:19:04 +08:00
/*
//------------------------------------------------------------------------------
//const unsigned char BusRegLen[] = {
// STD_30_LEN, STD_31_LEN, STD_32_LEN, STD_33_LEN, STD_34_LEN, STD_35_LEN, STD_36_LEN, STD_37_LEN,
// STD_38_LEN, STD_39_LEN, STD_3A_LEN, STD_3B_LEN, STD_3C_LEN, STD_3D_LEN, STD_3E_LEN, STD_3F_LEN,
//
// STD_40_LEN, STD_41_LEN, STD_42_LEN, STD_43_LEN, STD_44_LEN, STD_45_LEN, STD_46_LEN, STD_47_LEN,
// STD_48_LEN, STD_49_LEN, STD_4A_LEN, STD_4B_LEN, STD_4C_LEN, STD_4D_LEN, STD_4E_LEN, STD_4F_LEN,
//
// STD_50_LEN, STD_51_LEN, STD_52_LEN, STD_53_LEN, STD_54_LEN, STD_55_LEN, STD_56_LEN, STD_57_LEN,
// STD_58_LEN, STD_59_LEN, STD_5A_LEN, STD_5B_LEN, STD_5C_LEN, STD_5D_LEN, STD_5E_LEN, STD_5F_LEN,
//
// STD_60_LEN, STD_61_LEN, STD_62_LEN, STD_63_LEN, STD_64_LEN, STD_65_LEN, STD_66_LEN, STD_67_LEN,
// STD_68_LEN, STD_69_LEN, STD_6A_LEN, STD_6B_LEN, STD_6C_LEN, STD_6D_LEN, STD_6E_LEN, STD_6F_LEN,
//
// STD_70_LEN, STD_71_LEN, STD_72_LEN, STD_73_LEN, STD_74_LEN, STD_75_LEN, STD_76_LEN, STD_77_LEN,
// STD_78_LEN, STD_79_LEN, STD_7A_LEN, STD_7B_LEN, STD_7C_LEN, STD_7D_LEN, STD_7E_LEN, STD_7F_LEN,
//
// STD_80_LEN, STD_81_LEN, STD_82_LEN, STD_83_LEN, STD_84_LEN, STD_85_LEN, STD_86_LEN, STD_87_LEN,
// STD_88_LEN, STD_89_LEN, STD_8A_LEN, STD_8B_LEN, STD_8C_LEN, STD_8D_LEN, STD_8E_LEN, STD_8F_LEN,
//
// STD_90_LEN, STD_91_LEN, STD_92_LEN, STD_93_LEN, STD_94_LEN, STD_95_LEN, STD_96_LEN, STD_97_LEN,
// STD_98_LEN, STD_99_LEN, STD_9A_LEN, STD_9B_LEN, STD_9C_LEN, STD_9D_LEN, STD_9E_LEN, STD_9F_LEN,
//
// STD_A0_LEN, STD_A1_LEN, STD_A2_LEN, STD_A3_LEN, STD_A4_LEN, STD_A5_LEN, STD_A6_LEN, STD_A7_LEN,
// STD_A8_LEN, STD_A9_LEN, STD_AA_LEN, STD_AB_LEN, STD_AC_LEN, STD_AD_LEN, STD_AE_LEN, STD_AF_LEN,
//
// STD_B0_LEN, STD_B1_LEN, STD_B2_LEN, STD_B3_LEN, STD_B4_LEN, STD_B5_LEN, STD_B6_LEN, STD_B7_LEN,
// STD_B8_LEN, STD_B9_LEN, STD_BA_LEN, STD_BB_LEN, STD_BC_LEN, STD_BD_LEN, STD_BE_LEN, STD_BF_LEN,
//
// STD_C0_LEN, STD_C1_LEN, STD_C2_LEN, STD_C3_LEN, STD_C4_LEN, STD_C5_LEN, STD_C6_LEN, STD_C7_LEN,
// STD_C8_LEN, STD_C9_LEN, STD_CA_LEN, STD_CB_LEN, STD_CC_LEN, STD_CD_LEN, STD_CE_LEN, STD_CF_LEN,
//
// STD_D0_LEN, STD_D1_LEN, STD_D2_LEN, STD_D3_LEN, STD_D4_LEN, STD_D5_LEN, STD_D6_LEN, STD_D7_LEN,
// STD_D8_LEN, STD_D9_LEN, STD_DA_LEN, STD_DB_LEN, STD_DC_LEN, STD_DD_LEN, STD_DE_LEN, STD_DF_LEN,
//
// STD_E0_LEN, STD_E1_LEN, STD_E2_LEN, STD_E3_LEN, STD_E4_LEN, STD_E5_LEN, STD_E6_LEN, STD_E7_LEN,
// STD_E8_LEN, STD_E9_LEN, STD_EA_LEN, STD_EB_LEN, STD_EC_LEN, STD_ED_LEN, STD_EE_LEN, STD_EF_LEN,
//
// STD_F0_LEN, STD_F1_LEN, STD_F2_LEN, STD_F3_LEN, STD_F4_LEN, STD_F5_LEN, STD_F6_LEN, STD_F7_LEN,
// STD_F8_LEN, STD_F9_LEN, STD_FA_LEN, STD_FB_LEN, STD_FC_LEN, STD_FD_LEN, STD_FE_LEN, STD_FF_LEN,
//};
*/
NULL
2026-03-20 21:16:58 +08:00
//******************************************************************************
u16 SetupResponseTimeIndex(u16 response, u16 responseDefalt)
{
for(u16 I=0; I<RESP_MAX; I++) {
if(response == Timing[I]) {
return I;
}
}
parameterState = ABORD_OPERATION;
return responseDefalt;
}
//******************************************************************************
u16 SetupResponseTime(u16 response, u16 responseDefalt)
{
if(response < RESP_MAX) {
return Timing[response];
}
parameterState = ABORD_OPERATION;
return Timing[responseDefalt];
}
//******************************************************************************
void InitUseBusParameter(void)
{
NULL
2026-03-20 21:19:04 +08:00
unsigned int I;
NULL
2026-03-20 21:16:58 +08:00
DataPoint = &MAPPoint1;
for(I=0; I<STD_MAP_MAX; I++)
{
NULL
2026-03-20 21:19:04 +08:00
*DataPoint = ReadParameterFromMemory(MAP_SET1 + I*MAP_SET_WIDTH, MAP_SET_WIDTH, (unsigned int)MAPDefault[I]);
NULL
2026-03-20 21:16:58 +08:00
DataPoint--;
}
}
//******************************************************************************
void WriteInitUseBusParameter(void)
{
NULL
2026-03-20 21:19:04 +08:00
unsigned int I;
NULL
2026-03-20 21:16:58 +08:00
DataPoint = &MAPPoint1;
for(I=0; I<STD_MAP_MAX; I++)
{
NULL
2026-03-20 21:19:04 +08:00
*DataPoint = (unsigned int)MAPDefault[I];
tempL.Word[0] = (unsigned int)MAPDefault[I];
WriteParameterToEEPROM(MAP_SET1 + I*MAP_SET_WIDTH, MAP_SET_WIDTH);
NULL
2026-03-20 21:16:58 +08:00
DataPoint--;
}
}
//******************************************************************************
void UserReadDataProtocol(void)
{
u16 I;
DataPoint = &MBReg[INX_030];
// Read continuous address register
while(MBBuf.StartAddr < STD_DCOEF_NODE1)
{
if(MBBuf.ByteNumber < 2) return;
NULL
2026-03-20 21:19:04 +08:00
if(MBBuf.StartAddr < STD_REG_START)
{
NULL
2026-03-20 21:16:58 +08:00
//С<><D0A1>0x30δ<30><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>
MBBuf.DataByte = DataPoint[MBBuf.StartAddr + STD_MAP_SET1];
NULL
2026-03-20 21:19:04 +08:00
if(MBBuf.DataByte < STD_REG_START) tempL.Word[0] = 0;
NULL
2026-03-20 21:16:58 +08:00
else if(MBBuf.DataByte < STD_DCOEF_NODE1) tempL.Word[0] = DataPoint[MBBuf.DataByte - STD_REG_START];
NULL
2026-03-20 21:19:04 +08:00
else tempL.Word[0] = 0;
NULL
2026-03-20 21:16:58 +08:00
}
else tempL.Word[0] = DataPoint[MBBuf.StartAddr - STD_REG_START];
MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1];
MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0];
MBBuf.StartAddr++;
MBBuf.ByteNumber -= 2;
NULL
2026-03-20 21:19:04 +08:00
MBBuf.DataByte = 2;
NULL
2026-03-20 21:16:58 +08:00
}
// read record data
while(MBBuf.ByteNumber > 1)
{
MBBuf.DataByte = 2;
switch(MBBuf.StartAddr)
//switch(BusAdr[MBBuf.StartAddr])
{
case STD_DCOEF_NUM: tempL.Word[0] = dcoefNum; break;
case STD_DCOEF_NODE1:
case STD_DCOEF_NODE2:
case STD_DCOEF_NODE3:
case STD_DCOEF_NODE4:
case STD_DCOEF_NODE5:
case STD_DCOEF_NODE6:
case STD_DCOEF_NODE7:
case STD_DCOEF_NODE8:
case STD_DCOEF_NODE9:
case STD_DCOEF_NODE10:
case STD_DCOEF_NODE11:
case STD_DCOEF_NODE12:
case STD_DCOEF_NODE13:
case STD_DCOEF_NODE14:
case STD_DCOEF_NODE15:
case STD_DCOEF_NODE16:
case STD_DCOEF_NODE17:
case STD_DCOEF_NODE18:
case STD_DCOEF_NODE19:
case STD_DCOEF_NODE20:
MBBuf.DataByte = 4;
I = MBBuf.StartAddr - STD_DCOEF_NODE1;
I /= 3;
if(I >= dcoefNum) tempL.DWord = 0;
tempL.DWord = dcoefNode[I];
break;
case STD_DCOEF_VALUE1:
case STD_DCOEF_VALUE2:
case STD_DCOEF_VALUE3:
case STD_DCOEF_VALUE4:
case STD_DCOEF_VALUE5:
case STD_DCOEF_VALUE6:
case STD_DCOEF_VALUE7:
case STD_DCOEF_VALUE8:
case STD_DCOEF_VALUE9:
case STD_DCOEF_VALUE10:
case STD_DCOEF_VALUE11:
case STD_DCOEF_VALUE12:
case STD_DCOEF_VALUE13:
case STD_DCOEF_VALUE14:
case STD_DCOEF_VALUE15:
case STD_DCOEF_VALUE16:
case STD_DCOEF_VALUE17:
case STD_DCOEF_VALUE18:
case STD_DCOEF_VALUE19:
case STD_DCOEF_VALUE20:
I = MBBuf.StartAddr - STD_DCOEF_VALUE1;
I /= 3;
if(I >= dcoefNum) tempL.Word[0] = 0;
tempL.Word[0] = dcoefVal[I];
break;
case STD_ALARM_DEPTH: tempL.Word[0] = ALARM_DEPTH; break;
case STD_ALARM_WIDTH: tempL.Word[0] = ALARM_WIDTH; break;
case STD_HISTORY_DEPTH: tempL.Word[0] = HISTORY_DEPTH; break;
case STD_HISTORY_WIDTH: tempL.Word[0] = HISTORY_WIDTH; break;
case STD_DATE_DEPTH: tempL.Word[0] = DATE_DEPTH; break;
case STD_DATE_WIDTH: tempL.Word[0] = DATE_WIDTH; break;
default:
MBBuf.DataByte = MBBuf.StartAddr & 0xf000;
MBBuf.StartAddr &= 0x0fff;
switch(MBBuf.DataByte)
{
case STD_ALARM:
MBBuf.StartAddr *= ALARM_WIDTH;
MBBuf.StartAddr += ALARM_BASE;
ReadRecordToComBuf();
MBBuf.ByteNumber = 0;
return;
case STD_HISTORY:
MBBuf.StartAddr *= HISTORY_WIDTH;
MBBuf.StartAddr += HISTORY_BASE;
ReadRecordToComBuf();
MBBuf.ByteNumber = 0;
return;
case STD_DATE_ACC:
MBBuf.StartAddr *= DATE_WIDTH;
MBBuf.StartAddr += DATE_BASE;
ReadRecordToComBuf();
MBBuf.ByteNumber = 0;
return;
default: return;
}
}
NULL
2026-03-20 21:19:04 +08:00
// MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1];
// MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0];
// ModbusVariablePointerDec();
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();
}
}
//******************************************************************************
void UserWriteDataProtocol(void)
{
u16 I=0;
u16 BusAdr[50];
if(MBBuf.EndAddr > STD_DEFINE_MAX)
{
MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
return;
}
//----------------------------------------------------------------------------
while(MBBuf.StartAddr < MBBuf.EndAddr)
{
if(MBBuf.StartAddr < STD_REG_START)
{
// С<><D0A1>0x30δ<30><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>
MBBuf.DataByte = DataPoint[MBBuf.StartAddr + STD_MAP_SET1];
NULL
2026-03-20 21:19:04 +08:00
if((MBBuf.DataByte < STD_REG_START) || (MBBuf.DataByte > STD_REG_START)){
NULL
2026-03-20 21:16:58 +08:00
MBBuf.BusError = ILLEGAL_DATA_ADDRESS;
return;
}
BusAdr[I++] = MBBuf.DataByte;
}
else BusAdr[I++] = MBBuf.StartAddr;
MBBuf.StartAddr++;
if(I > 50) break;
}
//----------------------------------------------------------------------------
#ifndef ENABLE_USER_WP
#pragma message("[undefined] ENABLE_USER_WP")
#elif(ENABLE_USER_WP)
if(isOldProtocol) securityID = 0x0000AA55;
#else
securityID = 0x0000AA55;
#endif
//----------------------------------------------------------------------------
while(1)
{
if(MBBuf.BusError != 0) return; // V2004
if(ModbusVariablePointerProcess()) return;
switch(BusAdr[MBBuf.StartAddr])
{
#ifndef ENABLE_USER_WRITE_ACC
#pragma message("[undefined] ENABLE_USER_WRITE_ACC")
#elif(ENABLE_USER_WRITE_ACC)
case STD_ACC_INT:
if(MBBuf.ByteNumber < 4) return;
if(BusAdr[MBBuf.StartAddr+1] != STD_ACC_INT+1) return;
SetDWordCmdByCom(&tmpLA);
if(parameterState == ABORD_OPERATION) break;
if(tmpLA > 99999999) break;
ReleaseTotalToDisArray();
ConvertHEXToBCDArray(tmpLA, &Dis1[ACC_INT1], 8, HIGH_FIRST);
Dis2[ACC_INT1] = 0;
Dis2[ACC_INT2] = 0;
Dis2[ACC_INT3] = 0;
tmpLB = ReturnStartUnitBit(ACC_INT1);
for(I=ACC_INT1; I<ACC_DOT1; I++, tmpLB++) Dis2[tmpLB] = Dis1[I];
SetupACCArray();
ReleaseToIntAndDecimalBufForUart();
break;
case STD_ACC_DOT:
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if(CMDComPassword > 999) break;
ReleaseTotalToDisArray();
Dis2[ACC_DOT4] = 0;
Dis2[ACC_DOT5] = 0;
Dis2[ACC_DOT6] = 0;
ConvertHEXToBCDArray(CMDComPassword, &Dis1[ACC_DOT1], 3, HIGH_FIRST);
tmpLB = ReturnStartUnitBit(ACC_DOT1);
for(I=ACC_DOT1; I<ACC_DOT4; I++, tmpLB++) Dis2[tmpLB] = Dis1[I];
SetupACCArray();
ReleaseToIntAndDecimalBufForUart();
break;
case STD_ALARM_2: SetWordCmdByCom(&alarmState1); break;
case STD_HEX_ACC:
if(MBBuf.ByteNumber < 8) return;
if(BusAdr[MBBuf.StartAddr+1] != STD_HEX_ACC+1) return;
if(BusAdr[MBBuf.StartAddr+2] != STD_HEX_ACC+2) return;
if(BusAdr[MBBuf.StartAddr+3] != STD_HEX_ACC+3) return;
SetDWordCmdByCom(&tmpLA);
SetDWordCmdByCom(&tmpLB);
MBBuf.DataByte = 8;
if(parameterState == ABORD_OPERATION) break;
unsigned long long int tmPDA;
tmPDA = (unsigned long long int)tmpLA;
tmPDA <<= 32;
tmPDA |= (unsigned long long int)tmpLB;
if(tmPDA > 99999999999) break;
flowAccumulationInteger = (unsigned long int)(tmPDA/1000);
NULL
2026-03-20 21:19:04 +08:00
flowAccumulationDecimal = (unsigned int)(tmPDA-(unsigned long long int)flowAccumulationInteger*1000);
NULL
2026-03-20 21:16:58 +08:00
ConvertHEXToBCDArray(flowAccumulationInteger, &Dis1[ACC_INT1], 8, HIGH_FIRST);
ConvertHEXToBCDArray(flowAccumulationDecimal, &Dis1[ACC_DOT1], 3, HIGH_FIRST);
tmpLB = ReturnStartUnitBit(ACC_INT1);
Dis2[ACC_DOT4] = 0;
Dis2[ACC_DOT5] = 0;
Dis2[ACC_DOT6] = 0;
for(I=ACC_INT1; I<ACC_DOT4; I++, tmpLB++) Dis2[tmpLB] = Dis1[I];
SetupACCArray();
ReleaseToIntAndDecimalBufForUart();
break;
#endif
//------------------------------------------------------------------------------
//******************************************************************************
// 0x80~0xf0: read and write
//case STD_PROTOCOL: break;
#ifndef ENABLE_USER_UART
#pragma message("[undefined] ENABLE_USER_UART")
#elif(ENABLE_USER_UART)
NULL
2026-03-20 21:19:04 +08:00
case STD_SLAVER_ID:
FreeWriteWordByCom(&localAddress, SLAVER_ADDR, SLAVER_ADDR_WIDTH, SLAVER_ADDR_MAX, SLAVER_ADDR_MIN);
NULL
2026-03-20 21:16:58 +08:00
if(parameterState == ABORD_OPERATION) break;
BackupParameterToFlash();
break;
//case STD_COM_BPS: break;
#endif
//------------------------------------------------------------------------------
NULL
2026-03-20 21:19:04 +08:00
case STD_OUT_FR_MIN:
if(BusAdr[MBBuf.StartAddr+1] != STD_OUT_FR_MIN+1) return;
WriteDWordByCom(&minFlowRate, MIN_FLOW, MIN_FLOW_WIDTH, maxFlowRate>>1, 0);
NULL
2026-03-20 21:16:58 +08:00
break;
NULL
2026-03-20 21:19:04 +08:00
case STD_OUT_FR_MAX:
if(BusAdr[MBBuf.StartAddr+1] != STD_OUT_FR_MAX+1) return;
WriteDWordByCom(&maxFlowRate, MAX_FLOW, MAX_FLOW_WIDTH, 0x7fffffff, 0);
NULL
2026-03-20 21:16:58 +08:00
break;
//case STD_OUT_ANALOG_MIN: break;
//case STD_OUT_ANALOG_MAX: break;
//---------------------------------------------------------------------
#ifndef ENABLE_USER_GCF
#pragma message("[undefined] ENABLE_USER_GCF")
#elif(ENABLE_USER_GCF)
case STD_GCF:
NULL
2026-03-20 21:19:04 +08:00
WriteWordByCom(&GDCFactor, GCF_B, GCF_B_WIDTH, GCF_PARAMETER_MAX, GCF_PARAMETER_MIN);
NULL
2026-03-20 21:16:58 +08:00
if(parameterState == ABORD_OPERATION) break;
ComputeGCFFactor();
break;
#endif
//---------------------------------------------------------------------
//case STD_FILTER_DEPTH: break;
NULL
2026-03-20 21:19:04 +08:00
case STD_REPONSE_TIME: //WriteWordByCom(&factoryInterval, SAMPLE_PERIOD, SAMPLE_PERIOD_WIDTH, SAMPLE_PERIOD_MAX, SAMPLE_PERIOD_MIN); break;
NULL
2026-03-20 21:16:58 +08:00
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
CMDComPassword = SetupResponseTimeIndex(CMDComPassword, RESPONSE_TIME_DEFAULT);
if(parameterState == ABORD_OPERATION) break;
tempL.Word[0] = CMDComPassword;
NULL
2026-03-20 21:19:04 +08:00
responseTimeIndex = (unsigned int)WriteShortParameterToEEPROM(RESPONSE_TIME, RESPONSE_TIME_WIDTH);
NULL
2026-03-20 21:16:58 +08:00
responseTime = SetupResponseTime(responseTimeIndex, RESPONSE_TIME_DEFAULT);
break;
//-------------------------------------------------------------------------
#ifndef ENABLE_USER_OFFSET
#pragma message("[undefined] ENABLE_USER_OFFSET")
#elif(ENABLE_USER_OFFSET)
NULL
2026-03-20 21:19:04 +08:00
case STD_GAS_OFFSET_C: WriteWordByCom(&offsetGas, OFFSET_GAS, OFFSET_GAS_WIDTH, OFFSET_MAX, OFFSET_MIN); break;
NULL
2026-03-20 21:16:58 +08:00
#endif
//---------------------------------------------------------------------
#ifndef ENABLE_A_TYPE_FLOWRATE
#pragma message("[undefined] ENABLE_A_TYPE_FLOWRATE")
#elif(ENABLE_A_TYPE_FLOWRATE)
NULL
2026-03-20 21:19:04 +08:00
case STD_GAS_OFFSET_A: WriteWordByCom(&offsetGasA, OFFSET_A_GAS, OFFSET_A_GAS_WIDTH, OFFSET_A_MAX, OFFSET_A_MIN); break;
NULL
2026-03-20 21:16:58 +08:00
#endif
//---------------------------------------------------------------------
NULL
2026-03-20 21:19:04 +08:00
// V2004
NULL
2026-03-20 21:16:58 +08:00
#ifndef ENABLE_USER_SET_UNIT
#pragma message("[undefined] ENABLE_USER_SET_UNIT")
#elif(ENABLE_USER_SET_UNIT)
NULL
2026-03-20 21:19:04 +08:00
case STD_UNIT:
// SetWordCmdByCom(&CMDComPassword);
// if(parameterState == ABORD_OPERATION) break;
// if(CMDComPassword == flowUnit) break;
// ConvertAllFlowRateAndSave(tempL.Word[0]);
// break;
NULL
2026-03-20 21:16:58 +08:00
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if(CMDComPassword == flowUnit) break;
ConvertAllFlowRateAndSave(CMDComPassword);
break;
#endif
//--------------------------------------------------------------------------
NULL
2026-03-20 21:19:04 +08:00
case STD_AIR_FACTOR: WriteWordByCom(&VHHParameterAir, VHH_AIR_PARA, VHH_AIR_PARA_WIDTH, 46728, 26728); break;
case STD_FACTOR_VTH: WriteWordByCom(&VHHParameterScale, VHH_PARA_SCALE, VHH_PARA_SCALE_WIDTH, 65535, 0); break;
NULL
2026-03-20 21:16:58 +08:00
//--------------------------------------------------------------------------
#ifndef ENABLE_ACCPULSE
#pragma message("[undefined] ENABLE_ACCPULSE")
#elif(ENABLE_ACCPULSE)
case STD_PULSE_UNIT:
//WriteWordByCom(&factoryUnitPerPulse, PULSE_UNIT, PULSE_UNIT_WIDTH, PULSE_UNIT_MAX, 1);
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if((signed int)CMDComPassword > PULSE_UNIT_MAX) break;
if((signed int)CMDComPassword < PULSE_UNIT_MIN) break;
NULL
2026-03-20 21:19:04 +08:00
tempDev.Word[0] = CMDComPassword;
factoryUnitPerPulse = (signed int)WriteParameterToEEPROM(PULSE_UNIT, PULSE_UNIT_WIDTH);
NULL
2026-03-20 21:16:58 +08:00
lastRemaining = 0;
Total[MIN_BIT] = 0;
break;
NULL
2026-03-20 21:19:04 +08:00
case STD_IO_OUTPUT_LEVEL: WriteWordByCom(&PulseLevel, PULSE_LEVEL, PULSE_LEVEL_WIDTH, 1, 0); break;
NULL
2026-03-20 21:16:58 +08:00
#endif
//--------------------------------------------------------------------------
#ifndef ENABLE_LOWPOWER_MODE
#pragma message("[undefined] ENABLE_LOWPOWER_MODE")
#elif(ENABLE_LOWPOWER_MODE)
case STD_SAMPLE_PERIOD: // 0x95 //
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
CMDComPassword = SetupResponseTimeIndex(CMDComPassword, SAMPLE_PERIOD_DEFAULT);
if(parameterState == ABORD_OPERATION) break;
tempL.Word[0] = CMDComPassword;
NULL
2026-03-20 21:19:04 +08:00
factoryInterval = (unsigned int)WriteShortParameterToEEPROM(SAMPLE_PERIOD, SAMPLE_PERIOD_WIDTH);
NULL
2026-03-20 21:16:58 +08:00
samplingTiming = SetupResponseTime(factoryInterval, SAMPLE_PERIOD_DEFAULT);
break;
#endif
//--------------------------------------------------------------------------
#ifndef ENABLE_ALARM_ACC
#pragma message("[undefined] ENABLE_ALARM_ACC")
#elif(ENABLE_ALARM_ACC)
case STD_ALARM_ACC: // 0x96 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(BusAdr[MBBuf.StartAddr+1] != STD_ALARM_ACC+1) return;
NULL
2026-03-20 21:19:04 +08:00
WriteDWordByCom(&alarmAcc, ALARM_ACC, ALARM_ACC_WIDTH, ALARM_ACC_MAX, ALARM_ACC_MIN);
NULL
2026-03-20 21:16:58 +08:00
break;
#endif
//--------------------------------------------------------------------------
//case STD_ALARM_UPPER_FLOW 0x98 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//case STD_ALARM_LOWER_FLOW 0x9A // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//case STD_ALARM_FUN 0x9C // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ر<EFBFBD><D8B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//case STD_ALARM_OUT_DELAY 0x9D // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ر<EFBFBD><D8B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ (<28><>λ<EFBFBD><CEBB>s)
NULL
2026-03-20 21:19:04 +08:00
case STD_COM_DECIMAL: WriteWordByCom(&uartDecimalPoint, COM_DECIMAL_POINT, COM_DECIMAL_POINT_WIDTH, 4, 0); break;
case STD_RECORD_TIME: WriteWordByCom(&historyPeriod, HISTORY_PERIOD, HISTORY_PERIOD_WIDTH, 720, 0); break;
NULL
2026-03-20 21:16:58 +08:00
//case STD_REVERSE_FR_MIN: break;
//case STD_REVERSE_FR_MAX: break;
//--------------------------------------------------------------------------
#ifndef ENABLE_USER_I2C
#pragma message("[undefined] ENABLE_USER_I2C")
#elif(ENABLE_USER_I2C)
case STD_I2C_ADDR:
NULL
2026-03-20 21:19:04 +08:00
FreeWriteWordByCom(&localAddress, SLAVER_ADDR, SLAVER_ADDR_WIDTH, SLAVER_ADDR_MAX, SLAVER_ADDR_MIN);
NULL
2026-03-20 21:16:58 +08:00
I2CAddr = localAddress;
if(parameterState == ABORD_OPERATION) break;
BackupParameterToFlash();
// HWI2C_Init();
I2C_Slave_Init(100000 , 0x02);
break;
#endif
//--------------------------------------------------------------------------
//case STD_I2C_CRC_MOD: break;
NULL
2026-03-20 21:19:04 +08:00
case STD_TIMING_TXD_START: WriteWordByCom(&timingTxdStart, TIMING_TXD_START, TIMING_TXD_START_WIDTH, TIMING_TXD_START_MAX, TIMING_TXD_START_MIN); break;
case STD_TIMING_TXD_LEN: WriteWordByCom(&timingTxdLen, TIMING_TXD_LEN, TIMING_TXD_LEN_WIDTH, TIMING_TXD_LEN_MAX, TIMING_TXD_LEN_MIN); break;
case STD_TIMING_TXD_TIME: WriteWordByCom(&timingTxdTime, TIMING_TXD_TIME, TIMING_TXD_TIME_WIDTH, TIMING_TXD_TIME_MAX, 0); break;
NULL
2026-03-20 21:16:58 +08:00
//case STD_PRESSURE_OFFSET 0xA9 // ѹ<><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//case STD_LORA_ADR 0xAA // LORA <20><>ַ
//case STD_LORA_NETID 0xAB // LORA<52><41>·id
//case STD_LORA_CH 0xAC // LORA<52>ŵ<EFBFBD>
//case STD_LORA_STATE 0xAD // LORAģ<41>鹤<EFBFBD><E9B9A4>״̬
//---------------------------------------------------------------------
#ifndef ENABLE_KEY_FUNCTION
#pragma message("[undefined] ENABLE_KEY_FUNCTION")
#elif(ENABLE_KEY_FUNCTION)
NULL
2026-03-20 21:19:04 +08:00
case STD_KEY_PASSWORD: WriteDWordByCom(&keyPassWord, KEY_PASSWORD, KEY_PASSWORD_WIDTH, 99999, 0); break; // 0xAE <20><><EFBFBD>ð<EFBFBD><C3B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
NULL
2026-03-20 21:16:58 +08:00
#endif
//---------------------------------------------------------------------
#ifndef ENABLE_LEAK_DETECT
#pragma message("[undefined] ENABLE_LEAK_DETECT")
#elif(ENABLE_LEAK_DETECT)
NULL
2026-03-20 21:19:04 +08:00
case STD_LEAK_FR_MIN: WriteWordByCom(&minLeakFlowRate, MIN_LEAK_FLOW, MIN_LEAK_FLOW_WIDTH, MIN_LEAK_FLOW_MAX, MIN_LEAK_FLOW_MIN); break;
case STD_LEAK_FR_MAX: WriteWordByCom(&maxLeakFlowRate, MAX_LEAK_FLOW, MAX_LEAK_FLOW_WIDTH, MAX_LEAK_FLOW_MAX, MAX_LEAK_FLOW_MIN); break;
case STD_LEAK_TIMING: WriteWordByCom(&leakDetectTime, LEAK_TIME, LEAK_TIME_WIDTH, LEAK_TIME_MAX, 0); break;
NULL
2026-03-20 21:16:58 +08:00
#endif
//**************************************************************************
// 0XF0~0XFF: write only (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
//---------------------------------------------------------------------
case STD_CAL_OFFSET_CMD:
SetWordCmdByCom(&CMDComPassword);
#ifndef ENABLE_USER_OFFSET
#pragma message("[undefined] ENABLE_USER_OFFSET")
#elif(ENABLE_USER_OFFSET)
if(CMDComPassword == 0x0000AA55) CalibrateGasOffset();
#endif
break;
//---------------------------------------------------------------------
#ifndef ENABLE_USER_WRITE_ACC
#pragma message("[undefined] ENABLE_USER_WRITE_ACC")
#elif(ENABLE_USER_WRITE_ACC)
case STD_CLR_RECORD:
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if(CMDComPassword == 0x0001) ClearACC();
break;
#endif
//------------------------------------------------------------------------
case STD_RESET_DEFAULT:
SetWordCmdByCom(&CMDComPassword);
if(parameterState == ABORD_OPERATION) break;
if(CMDComPassword == 0x01) WriteInitUseBusParameter();
#if(ENABLE_USER_RESET_CORR)
else if(CMDComPassword == 0x02) DefaultDevCoef();
#endif
break;
//------------------------------------------------------------------------
case STD_CAL_FULL_RANGE_CMD:
SetWordCmdByCom(&CMDComPassword);
#ifndef ENABLE_DENSITY_DETECT
#pragma message("[undefined] ENABLE_DENSITY_DETECT")
#elif(ENABLE_DENSITY_DETECT)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У׼
if(CMDComPassword == 0x0000AAFF)
{
tempL.Word[0] = voltageDetected[VHPA];
NULL
2026-03-20 21:19:04 +08:00
densityFSParameter = (unsigned int)WriteShortParameterToEEPROM(DENSITY_FS_PARA, DENSITY_FS_PARA_WIDTH);
NULL
2026-03-20 21:16:58 +08:00
break;
}
// <20>Ͷ<EFBFBD>У׼
if(CMDComPassword == 0x0000AA00)
{
tempL.Word[0] = voltageDetected[VHPA];
NULL
2026-03-20 21:19:04 +08:00
VHHParameterAir = (unsigned int)WriteShortParameterToEEPROM(VHH_AIR_PARA, VHH_AIR_PARA_WIDTH);
NULL
2026-03-20 21:16:58 +08:00
break;
}
#endif
break;
//---------------------------------------------------------------------
// V2004
#ifndef ENABLE_USER_WP
#pragma message("[undefined] ENABLE_USER_WP")
#elif(ENABLE_USER_WP)
case STD_PASSWORD_CMD:
FreeSetWordCmdByCom(&CMDComPassword);
if(CMDComPassword != 0x0000AA55) break;
securityID = 0x0000AA55;
IDvalidTime = 0;
break;
#endif
//************************************************************************
// map config
case STD_MAP_SET1:
case STD_MAP_SET2:
case STD_MAP_SET3:
case STD_MAP_SET4:
case STD_MAP_SET5:
case STD_MAP_SET6:
case STD_MAP_SET7:
case STD_MAP_SET8:
case STD_MAP_SET9:
case STD_MAP_SET10:
case STD_MAP_SET11:
case STD_MAP_SET12:
case STD_MAP_SET13:
case STD_MAP_SET14:
case STD_MAP_SET15:
case STD_MAP_SET16:
case STD_MAP_SET17:
case STD_MAP_SET18:
case STD_MAP_SET19:
case STD_MAP_SET20:
case STD_MAP_SET21:
case STD_MAP_SET22:
case STD_MAP_SET23:
case STD_MAP_SET24:
case STD_MAP_SET25:
case STD_MAP_SET26:
case STD_MAP_SET27:
case STD_MAP_SET28:
case STD_MAP_SET29:
case STD_MAP_SET30:
case STD_MAP_SET31:
case STD_MAP_SET32:
case STD_MAP_SET33:
case STD_MAP_SET34:
case STD_MAP_SET35:
case STD_MAP_SET36:
case STD_MAP_SET37:
case STD_MAP_SET38:
case STD_MAP_SET39:
case STD_MAP_SET40:
case STD_MAP_SET41:
case STD_MAP_SET42:
case STD_MAP_SET43:
case STD_MAP_SET44:
case STD_MAP_SET45:
case STD_MAP_SET46:
case STD_MAP_SET47:
case STD_MAP_SET48:
DataPoint = &MAPPoint1;
MBBuf.DataByte = BusAdr[MBBuf.StartAddr] - STD_MAP_SET1;
DataPoint -= MBBuf.DataByte;
NULL
2026-03-20 21:19:04 +08:00
WriteWordByCom(DataPoint, MAP_SET1 + MBBuf.DataByte * MAP_SET_WIDTH, MAP_SET_WIDTH, 256, 0);
NULL
2026-03-20 21:16:58 +08:00
MBBuf.DataByte = 2;
break;
NULL
2026-03-20 21:19:04 +08:00
case STD_DCOEF_NUM: WriteWordByCom(&dcoefNum, DCOEF_NUM, DCOEF_NUM_WIDTH, 20, 3); break;
NULL
2026-03-20 21:16:58 +08:00
case STD_DCOEF_NODE1:
case STD_DCOEF_NODE2:
case STD_DCOEF_NODE3:
case STD_DCOEF_NODE4:
case STD_DCOEF_NODE5:
case STD_DCOEF_NODE6:
case STD_DCOEF_NODE7:
case STD_DCOEF_NODE8:
case STD_DCOEF_NODE9:
case STD_DCOEF_NODE10:
case STD_DCOEF_NODE11:
case STD_DCOEF_NODE12:
case STD_DCOEF_NODE13:
case STD_DCOEF_NODE14:
case STD_DCOEF_NODE15:
case STD_DCOEF_NODE16:
case STD_DCOEF_NODE17:
case STD_DCOEF_NODE18:
case STD_DCOEF_NODE19:
case STD_DCOEF_NODE20:
I = BusAdr[MBBuf.StartAddr] - STD_DCOEF_NODE1;
I /= 3;
if(I >= dcoefNum) return;
SetDWordCmdByCom(&tmpLA);
if(parameterState == ABORD_OPERATION) return;
dcoefNode[I] = tmpLA;
NULL
2026-03-20 21:19:04 +08:00
IDvalidTime = 0;
NULL
2026-03-20 21:16:58 +08:00
HWState.EnableCheckCorr = 0;
StoreDevCoefNodeAndValue(I);
break;
case STD_DCOEF_VALUE1:
case STD_DCOEF_VALUE2:
case STD_DCOEF_VALUE3:
case STD_DCOEF_VALUE4:
case STD_DCOEF_VALUE5:
case STD_DCOEF_VALUE6:
case STD_DCOEF_VALUE7:
case STD_DCOEF_VALUE8:
case STD_DCOEF_VALUE9:
case STD_DCOEF_VALUE10:
case STD_DCOEF_VALUE11:
case STD_DCOEF_VALUE12:
case STD_DCOEF_VALUE13:
case STD_DCOEF_VALUE14:
case STD_DCOEF_VALUE15:
case STD_DCOEF_VALUE16:
case STD_DCOEF_VALUE17:
case STD_DCOEF_VALUE18:
case STD_DCOEF_VALUE19:
case STD_DCOEF_VALUE20:
I = BusAdr[MBBuf.StartAddr] - STD_DCOEF_VALUE1;
I /= 3;
if(I >= dcoefNum) return;
SetWordCmdByCom(&tempL.Word[0]);
if(parameterState == ABORD_OPERATION) return;
if(tempL.Word[0] > METER_PARAMETER_MAX) return;
if(tempL.Word[0] < METER_PARAMETER_MIN) return;
NULL
2026-03-20 21:19:04 +08:00
IDvalidTime = 0;
NULL
2026-03-20 21:16:58 +08:00
dcoefVal[I] = tempL.Word[0];
StoreDevCoefNodeAndValue(I);
HWState.EnableCheckCorr = 0;
break;
default:
tempL.Word[0] = 0;
MBBuf.DataByte = 2;
break;
}
}
}
/******************************************************************************/
void AutoTransmitData(void)
{
// if(comState.Sending) return;
//
// comState.ReceivedData = 0;
// autoTxdCounter = 0;
// comState.EnableAutoTxdData = 0;
//
// MBBuf.RxPointer[0] = (unsigned char)localAddress;
// MBBuf.RxPointer[1] = (unsigned char)READ_HOLDING_REGISTERS;
// MBBuf.ByteNumber = timingTxdLen*2;
// if(MBBuf.ByteNumber > 100) MBBuf.ByteNumber = 100;
// MBBuf.RxPointer[2] = MBBuf.ByteNumber;
//
// MBBuf.StartAddr = timingTxdStart;
// MBBuf.TxdLen = MBBuf.ByteNumber;
// MBBuf.TxdLen += 4;
// Index = 3;
// UserReadDataProtocol();
// ComputeCRCForTransmitData();
// StartDMAForTxdData();
}
Reference in New Issue Copy Permalink