package com.szpg.plc.protocol.fins;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import org.apache.log4j.Logger;
import com.szpg.db.dao.PgAcuRdcmdDao;
import com.szpg.db.dao.impl.PgAcuRdcmdDaoImpl;
import com.szpg.db.data.PgAcuRdcmd;
import com.szpg.plc.message.AppMessage;
import com.szpg.plc.message.AppMessageConstants;
import com.szpg.plc.message.UnKnownMessage;
import com.szpg.plc.message.command.LinkCommand;
import com.szpg.plc.message.command.read.ReadCH4ParamCommand;
import com.szpg.plc.message.response.LinkCommandResponse;
import com.szpg.plc.message.response.read.ReadCH4ParamCommandResponse;
import com.szpg.plc.protocol.DTProtocolInterface;
import com.szpg.plc.protocol.fins.frame.FINSByteFrame;
import com.szpg.plc.protocol.fins.frame.FINSByteFrameTool;
import com.szpg.plc.util.ByteUtil;
import com.szpg.plc.util.Bytes;
public class FINSDTProtocolImp implements DTProtocolInterface {
private final Logger logger = Logger.getLogger(this.getClass().getName()); // 输出到message
/**
* 将字节数组解析为收到的消息对象
*
* @param byte[] byteMessage
* @return RecievedMessage
*/
public AppMessage bytesToMessage(byte[] byteMessage) {
AppMessage received = null;
FINSByteFrame finsFrame = new FINSByteFrame(byteMessage);
if (!finsFrame.valid) {
received = new UnKnownMessage(byteMessage);
received.setTime(Calendar.getInstance());
return received;
}
// 根据不同字节内容，解析为各类型应用消息
String commandStr = FINSByteFrameTool.getCommandStr(byteMessage);
// 握手消息的响应
if (commandStr.equalsIgnoreCase("00000001")) {
received = bytesToLinkCommandResponse(finsFrame);
}
// 读写命令的响应
if (commandStr.equalsIgnoreCase("00000002")) {
String commandCode = FINSByteFrameTool.getFinsCommandCode(byteMessage);
if (commandCode.equalsIgnoreCase("0101")) {
// 读内存命令响应的解析
// 1首先解析出消息的PLC端地址(即响应消息的源地址)和返回的内存内容的字数
String dest = FINSByteFrameTool.getControlSour(byteMessage); //命令的目标地址即响应消息的源地址
int count = FINSByteFrameTool.getDataWithoutEndCode(byteMessage).length;
// 2查询数据中最近的有效的读内存命令，获取其读取的参数类型
PgAcuRdcmdDao readCmdDao = new PgAcuRdcmdDaoImpl();
PgAcuRdcmd readCmd = readCmdDao.findLatestCmdByDestAndCount(dest, count);
if (null != readCmd) {
String commandType = readCmd.getCmd_type();
// 3根据参数类型调用相应的方法进行解析
switch(commandType) {
case AppMessageConstants.CMD_TYPE_READCH4PARAM:
received = bytesToReadCH4ParamCommand(finsFrame);
}
// 4将有效的命令的是否有响应字段置1
readCmdDao.updateCmdRecordResponsed(readCmd.getId());
}
} else if (commandCode.equalsIgnoreCase("0102")) {
// 写内存命令响应
}
}
//
//
// byte typeb = finsFrame.FRAME_DATA_AFN;
// int type = ByteUtil.binToInt(typeb);
// switch (type) {
// case FINSConstants.DATA_AFN_LOGIN: // 链路监测消息
// received = bytesToLinkCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_TIMINGDATA: // 定时自报实时值
// received = bytesToTimingDataMessage(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_QUERYREALTIMEVALUE: // 查询实时值响应
// received = bytesToQueryRealTimeValueCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYREALTIMESTATUS: // 查询实时状态响应
// received = bytesToQueryRealTimeStatusCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETADDRESS: // 设置终端地址响应消息
// received = bytesToSetAddressCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYADDRESS: // 查询终端地址响应消息
// received = bytesToQueryAddressResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETCLOCK: // 设置终端时钟响应消息
// received = bytesToSetClockCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYCLOCK: // 查询终端时钟响应消息
// received = bytesToQueryClockCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETWORKPATTERN: // 设置终端工作模式响应消息
// received = bytesToSetPatternCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWORKPATTERN: // 查询终端工作模式响应消息
// received = bytesToQueryPatternCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETINTERVAL: // 设置终端自报种类及时间间隔
// received = bytesToSetIntervalCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYINTERVAL: // 查询终端自报种类及时间间隔
// received = bytesToQueryIntervalCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETWARNING: // 设置终端剩余水量报警值
// received = bytesToSetWarningCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWARNING: // 查询终端剩余水量报警值
// received = bytesToQueryWarningCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETWATERLEVELPARAM: // 设置终端水位参数
// received = bytesToSetWlParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWATERLEVELPARAM: // 查询终端水位参数
// received = bytesToQueryWlParamCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETWATERPRESSUREPARAM: // 设置终端水压参数
// received = bytesToSetWpParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWATERPRESSUREPARAM: // 查询终端水压参数
// received = bytesToQueryWpParamCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETWATERFLOWUPPERPARAM: // 设置终端流量参数
// received = bytesToSetWfParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWATERFLOWUPPERPARAM: // 查询终端流量参数
// received = bytesToQueryWfParamCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETWATERQUALITYUPPERPARAM: // 设置终端水质参数
// received = bytesToSetWqUpperParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_SETWATERQUALITYLOWERPARAM:
// received = bytesToSetWqLowerParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWATERQUALITYUPPERPARAM: // 查询终端水质参数
// received = bytesToQueryWqUpperParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYWATERQUALITYLOWERPARAM:
// received = bytesToQueryWqLowerParamCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETRTTYPES: // 设置终端需查询的实时数据种类
// received = bytesToSetRttypesCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYRTTYPES: // 查询终端需查询的实时数据种类
// received = bytesToQueryRttypesCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETCHARGING: // 设置终端充值量
// received = bytesToSetChargingCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_QUERYCHARGING: // 查询终端充值量和剩余水量
// received = bytesToQueryChargingCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETTHRESHOLD: // 设置终端启报阈值及存储时间段间隔
// received = bytesToSetThresholdCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_SETFIXEDVALUE: // 设置终端定值量
// received = bytesToSetFixedValueCommandResponse(finsFrame);
// break;
//
//
// case GBConstants.DATA_AFN_SETFLOWINIT: // 设置终端水量表底值
// received = bytesToSetFlowInitCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_ENABLEICCARD: // 设置终端IC卡功能
// received = bytesToEnableICCardCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_DISABLEICCARD:
// received = bytesToDisableICCardCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_ENABLEFIXEDVAL: // 设置终端定值控制功能
// received = bytesToEnableFixedValCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_DISABLEFIXEDVAL:
// received = bytesToDisableFixedValCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_REMOTEOPENPUMP: // 遥控开关水泵/闸门
// received = bytesToRemoteOpenPumpCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_REMOTECLOSEPUMP:
// received = bytesToRemoteClosePumpCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_RESETPARAM: // 复位终端参数
// received = bytesToResetParamCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_CLEARHISTORY: // 清空终端历史数据单元
// received = bytesToClearHistoryCommandResponse(finsFrame);
// break;
// case GBConstants.DATA_AFN_SETPASSWORD: // 修改终端密码
// received = bytesToSetPasswordCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_QUERYEMOTOSS:// 查询水泵电机实时工作数据
// received = bytesToQueryRealTimeMotoValueCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_QUERYEVENTREC: // 查询遥测终端事件记录
// received = bytesToQueryEventRecordsCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_QUERYMEMERYVALUE: // 查询终端内存自报数据
// received = bytesToQueryMemeryValueCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_QUERYHARDDISCVALUE: // 查询终端固态存储数据
// received = bytesToQueryHDValueCommandResponse(finsFrame);
// break;
//
// case GBConstants.DATA_AFN_WARNING: // 随机自报报警数据
// received = bytesToWarningMessage(finsFrame);
// break;
// case GBConstants.DATA_AFN_SETTINGDATA: // 人工置数
// received = bytesToSettingDataMessage(finsFrame);
// break;
//
// default:
// received = new UnKnownMessage(byteMessage);
// received.setTime(Calendar.getInstance());
// }
return received;
}
/**
* 将握手响应字节数组转换为消息对象
*
* @param byteMessage
* @return
*/
private AppMessage bytesToLinkCommandResponse(FINSByteFrame finsFrame) {
LinkCommandResponse lcr = new LinkCommandResponse();
byte[] data = finsFrame.TEXT_DATA_BODY;
if (data.length == 8) {
String sour = ByteUtil.binToHexString(data, 8, 16); //握手响应消息的源地址，实际上是PLC地址
String dest = ByteUtil.binToHexString(data, 0, 8); //握手响应消息的目标地址，实际上是本机地址
lcr.setMessageProducerId(sour);
lcr.setDestinationId(dest);
lcr.setTime(Calendar.getInstance());
lcr.setValid(true);
} else {
lcr.setValid(false);
logger.debug("握手命令响应消息数据域长度不符");
}
return lcr;
}
/**
* 将查询甲烷参数响应消息字节数组转换为消息对象
*
* @param byteMessage
* @return
*/
private AppMessage bytesToReadCH4ParamCommand(FINSByteFrame finsFrame) {
ReadCH4ParamCommandResponse rcpcr = new ReadCH4ParamCommandResponse();
byte[] body = finsFrame.TEXT_DATA_BODY;
rcpcr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
if (body[2] == 0x00 && body[3] == 0x00) {
// 正常返回
byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
int chct = data.length / (2 * 2 * 2); //甲烷监测点的数量/每个甲烷点位的参数包括2个变量、每个变量占2个字，每个字占2个字节
for (int i = 0; i < chct; i++) {
byte[] valueByte = new byte[] { data[i*8 + 2], data[i*8 + 3], data[i*8], data[i*8 + 1] };
byte[] thresholdByte = new byte[] { data[i*8 + 6], data[i*8 + 7], data[i*8 + 4], data[i*8 + 5] };
float value = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(valueByte), 16)); //甲烷浓度值
float threshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(thresholdByte), 16)); //甲烷报警阈值
rcpcr.getJwnd().add(value);
rcpcr.getJwldbjz().add(threshold);
}
}
return rcpcr;
}
//
// /**
// * 将查询终端地址响应消息字节数组解析为消息对象AFN=50H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryAddressResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryAddressCommandResponse qacr = new QueryAddressCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 5) {
// String addressRes = ByteUtil.bcdToString(new byte[] { data[0], data[1], data[2] }) +
// ByteUtil.binToHexString(new byte[] { data[4], data[3] });
// if (addressRes.length() == 10) {
// qacr.setValid(true);
// qacr.setAddress(addressRes);
// } else {
// logger.error("查询终端地址响应消息解析错误");
// qacr.setValid(false);
// }
// } else {
// logger.error("查询终端地址响应消息长度错误");
// qacr.setValid(false);
// }
//
// return qacr;
// }
//
// /**
// * 将设置终端时钟响应消息字节数组解析为消息对象AFN=11H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetClockCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetClockCommandResponse sccr = new SetClockCommandResponse(Calendar.getInstance(), address);
// if (data.length == 6) {
// Calendar clock = Calendar.getInstance();
//
// clock.setLenient(false);
// try {
// clock.set(Calendar.SECOND, ByteUtil.bcdToInt(data[0]));
// clock.set(Calendar.MINUTE, ByteUtil.bcdToInt(data[1]));
// clock.set(Calendar.HOUR_OF_DAY, ByteUtil.bcdToInt(data[2]));
// clock.set(Calendar.DAY_OF_MONTH, ByteUtil.bcdToInt(data[3]));
// clock.set(Calendar.MONTH, ByteUtil.bcdToInt((byte) (data[4] & 0x1F)) - 1);
// clock.set(Calendar.YEAR, ByteUtil.bcdToInt(data[5]) + 2000);
//
// clock.getTime();
// } catch (IllegalArgumentException ex) {
// logger.error("时间字段超出范围");
// sccr.setValid(false);
// return sccr;
// } catch (Exception re) {
// logger.error("时间字段解析异常");
// sccr.setValid(false);
// return sccr;
// }
//
// sccr.setNewClock(clock);
//
// sccr.setValid(true);
// sccr.setSuccess(true);
// } else {
// logger.error("设置终端时钟响应消息长度错误");
// sccr.setValid(false);
// }
//
// return sccr;
// }
//
// /**
// * 将查询终端时钟响应消息字节数组解析为消息对象AFN=51H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryClockCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryClockCommandResponse qccr = new QueryClockCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 6) {
// Calendar clock = Calendar.getInstance();
//
// clock.setLenient(false);
//
// clock.set(Calendar.SECOND, ByteUtil.bcdToInt(data[0]));
// clock.set(Calendar.MINUTE, ByteUtil.bcdToInt(data[1]));
// clock.set(Calendar.HOUR_OF_DAY, ByteUtil.bcdToInt(data[2]));
// clock.set(Calendar.DAY_OF_MONTH, ByteUtil.bcdToInt(data[3]));
// clock.set(Calendar.MONTH, ByteUtil.bcdToInt((byte) (data[4] & 0x1F)) - 1);
// clock.set(Calendar.YEAR, ByteUtil.bcdToInt(data[5]) + 2000);
//
// try {
// clock.getTime();
// } catch (IllegalArgumentException ex) {
// logger.error("时间字段超出范围");
// qccr.setValid(false);
// return qccr;
// }
//
// qccr.setClock(clock);
// qccr.setValid(true);
// } else {
// logger.error("查询终端时钟响应消息长度错误");
// qccr.setValid(false);
// }
//
// return qccr;
// }
//
// /**
// * 将设置终端工作模式响应消息字节数组解析为消息对象AFN=12H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetPatternCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetPatternCommandResponse spcr = new SetPatternCommandResponse(Calendar.getInstance(), address);
// if (data.length == 1) {
// String patternRes = ByteUtil.binToHexString(data);
//
// spcr.setValid(true);
// spcr.setSuccess(true);
// spcr.setWorkPattern(patternRes);
// } else {
// logger.error("设置终端工作模式响应消息长度错误");
// spcr.setValid(false);
// }
//
// return spcr;
// }
//
// /**
// * 将查询终端工作模式响应消息字节数组解析为消息对象AFN=52H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryPatternCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryPatternCommandResponse qpcr = new QueryPatternCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// String patternRes = ByteUtil.binToHexString(data);
//
// qpcr.setValid(true);
// qpcr.setWorkPattern(patternRes);
// } else {
// logger.error("查询终端工作模式响应消息长度错误");
// qpcr.setValid(false);
// }
//
// return qpcr;
// }
//
// /**
// * 将设置终端自报种类及时间间隔响应消息字节数组解析为消息对象AFN=A1H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetIntervalCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetIntervalCommandResponse sicr = new SetIntervalCommandResponse(Calendar.getInstance(), address);
// Map<String, Integer> intervals = new HashMap<String, Integer>();
//
// // 解析并设置数据域
// if (data.length == 30) {
// String bin = ByteUtil.binToBinString(new byte[] { data[1], data[0] }).substring(2); // D15D14备用
// int len = bin.length();
// for (int i = 0; i < len; i++) {
// if (bin.substring(len - 1 - i, len - i).equals("1")) {
// intervals.put(QueryIntervalCommandResponse.index[i], Integer.valueOf((int) ByteUtil.bcdToLong(new byte[] { data[2 * (i + 1) + 1], data[2 * (i + 1)] })));
// }
// }
//
// sicr.setValid(true);
// sicr.setIntervals(intervals);
//
// sicr.setValid(true);
// sicr.setSuccess(true);
// } else {
// logger.error("设置终端自报种类及时间间隔响应消息长度错误");
// sicr.setValid(false);
// }
//
// return sicr;
// }
//
// /**
// * 将查询终端自报种类及时间间隔响应消息字节数组解析为消息对象AFN=53H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryIntervalCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryIntervalCommandResponse qicr = new QueryIntervalCommandResponse(Calendar.getInstance(), address);
// Map<String, Integer> intervals = new HashMap<String, Integer>();
//
// // 解析并设置数据域
// if (data.length == 30) {
// String bin = ByteUtil.binToBinString(new byte[] { data[1], data[0] }).substring(2); // D15D14备用
// int len = bin.length();
// for (int i = 0; i < len; i++) {
// if (bin.substring(len - 1 - i, len - i).equals("1")) {
// intervals.put(QueryIntervalCommandResponse.index[i], Integer.valueOf((int) ByteUtil.bcdToLong(new byte[] { data[2 * (i + 1) + 1], data[2 * (i + 1)] })));
// }
// }
//
// qicr.setValid(true);
// qicr.setIntervals(intervals);
// } else {
// logger.error("查询终端自报种类及时间间隔响应消息长度错误");
// qicr.setValid(false);
// }
//
// return qicr;
// }
//
// /**
// * 将设置终端需查询的实时数据种类响应消息字节数组解析为消息对象AFN=A0H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetRttypesCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetRttypesCommandResponse srcr = new SetRttypesCommandResponse(Calendar.getInstance(), address);
// Set<String> rttypes = new HashSet<String>();
//
// // 解析并设置数据域
// if (data.length == 2) {
// String bin = ByteUtil.binToBinString(new byte[] { data[1], data[0] }).substring(1); // D15备用
// int len = bin.length();
// for (int i = 0; i < len; i++) {
// if (bin.substring(len - 1 - i, len - i).equals("1")) {
// rttypes.add(QueryRttypesCommandResponse.index[i]);
// }
// }
// srcr.setRttypes(rttypes);
//
// srcr.setValid(true);
// srcr.setSuccess(true);
// } else {
// logger.error("设置终端需查询的实时数据种类响应消息长度错误");
// srcr.setValid(false);
// }
//
// return srcr;
// }
//
// /**
// * 将查询终端需查询的实时数据种类响应消息字节数组解析为消息对象AFN=54H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryRttypesCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryRttypesCommandResponse qrcr = new QueryRttypesCommandResponse(Calendar.getInstance(), address);
// Set<String> rttypes = new HashSet<String>();
//
// // 解析并设置数据域
// if (data.length == 2) {
// String bin = ByteUtil.binToBinString(new byte[] { data[1], data[0] }).substring(1); // D15备用
// int len = bin.length();
// for (int i = 0; i < len; i++) {
// if (bin.substring(len - 1 - i, len - i).equals("1")) {
// rttypes.add(QueryRttypesCommandResponse.index[i]);
// }
// }
//
// qrcr.setValid(true);
// qrcr.setRttypes(rttypes);
// } else {
// logger.error("查询终端需查询的实时数据种类响应消息长度错误");
// qrcr.setValid(false);
// }
//
// return qrcr;
// }
//
// /**
// * 将设置终端充值量响应消息字节数组解析为消息对象AFN=15H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetChargingCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetChargingCommandResponse sccr = new SetChargingCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 4) {
// String charging = ByteUtil.bcdToString(new byte[] { data[3], data[2], data[1], data[0] });
//
// sccr.setCharging(Integer.parseInt(charging));
// sccr.setValid(true);
// sccr.setSuccess(true);
// } else {
// logger.error("设置终端充值量响应消息长度错误");
// sccr.setValid(false);
// }
//
// return sccr;
// }
//
// /**
// * 将查询终端充值量和剩余水量响应消息字节数组解析为消息对象AFN=55H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryChargingCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryChargingCommandResponse qccr = new QueryChargingCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 9) {
// String charging = ByteUtil.bcdToString(new byte[] { data[3], data[2], data[1], data[0] });
// String current = ByteUtil.bcdToString(new byte[] { (byte) (data[8] & 0x7F), data[7], data[6], data[5], data[4] });
//
// if (charging.equals("") == false && current.equals("") == false) {
// qccr.setValid(true);
// qccr.setCharging(Integer.parseInt(charging));
// // 判断剩余水量正负符号
// if ((data[8] & 0x80) == 0x80) {
// qccr.setCurrent(Long.parseLong(current) * -1);
// } else {
// qccr.setCurrent(Long.parseLong(current));
// }
// } else {
// logger.error("查询终端充值量和剩余水量响应消息解析错误");
// qccr.setValid(false);
// }
// } else {
// logger.error("查询终端充值量和剩余水量响应消息长度错误");
// qccr.setValid(false);
// }
//
// return qccr;
// }
//
// /**
// * 将设置终端剩余水量报警值响应消息字节数组解析为消息对象AFN=16H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetWarningCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetWarningCommandResponse swcr = new SetWarningCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 3) {
// String warning = ByteUtil.bcdToString(new byte[] { data[2], data[1], data[0] });
// if (warning.equals("") == false) {
// swcr.setNewWarning(Integer.parseInt(warning));
// }
//
// swcr.setValid(true);
// swcr.setSuccess(true);
// } else {
// logger.error("设置终端剩余水量报警值响应消息长度错误");
// swcr.setValid(false);
// }
//
// return swcr;
// }
//
// /**
// * 将查询终端剩余水量报警值响应消息字节数组解析为消息对象AFN=56H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryWarningCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryWarningCommandResponse qwcr = new QueryWarningCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 8) {
// String warning = ByteUtil.bcdToString(new byte[] { data[2], data[1], data[0] });
// String current = ByteUtil.bcdToString(new byte[] { (byte) (data[7] & 0x7F), data[6], data[5], data[4], data[3] });
//
// if (warning.equals("") == false && current.equals("") == false) {
// qwcr.setValid(true);
// qwcr.setWarning(Integer.parseInt(warning));
// // 判断剩余水量正负符号
// if ((data[7] & 0x80) == 0x80) {
// qwcr.setCurrent(Long.parseLong(current) * -1);
// } else {
// qwcr.setCurrent(Long.parseLong(current));
// }
// } else {
// logger.error("查询终端剩余水量报警值响应消息解析错误");
// qwcr.setValid(false);
// }
// } else {
// logger.error("查询终端剩余水量报警值响应消息长度错误");
// qwcr.setValid(false);
// }
//
// return qwcr;
// }
//
// /**
// * 将设置终端水位参数响应消息字节数组解析为消息对象AFN=17H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetWlParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetWlParamCommandResponse swpcr = new SetWlParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length >= 7 && data.length % 7 == 0) {
// int n = data.length / 7; // n表示水位点个数
// List<List<Double>> wlParams = new ArrayList<List<Double>>(n);
//
// // 解析多个水位点的值
// for (int i = 0; i < n; i++) {
// List<Double> item = new ArrayList<Double>();
//
// String benchmark = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 7 + 2] & 0x7F), data[i * 7 + 1], data[i * 7 + 0] });
// String lower = ByteUtil.bcdToString(new byte[] { data[i * 7 + 4], data[i * 7 + 3] });
// String upper = ByteUtil.bcdToString(new byte[] { data[i * 7 + 6], data[i * 7 + 5] });
//
// if (benchmark.equals("") == false && lower.equals("") == false && upper.equals("") == false) {
// // 判断剩余水量正负符号
// if ((data[i * 7 + 2] & 0x80) == 0x80) {
// item.add(0, Double.valueOf(Integer.parseInt(benchmark) * -0.01));
// } else {
// item.add(0, Double.valueOf(Integer.parseInt(benchmark) * 0.01));
// }
// item.add(1, Double.valueOf(Integer.parseInt(upper) * 0.01));
// item.add(2, Double.valueOf(Integer.parseInt(lower) * 0.01));
//
// wlParams.add(item);
// }
// }
// swpcr.setWlParams(wlParams);
//
// swpcr.setValid(true);
// swpcr.setSuccess(true);
// } else {
// logger.error("设置水位参数命令响应数据域长度错误");
// swpcr.setValid(false);
// }
//
// return swpcr;
// }
//
// /**
// * 将查询终端水位参数响应消息字节数组解析为消息对象AFN=57H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryWlParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryWlParamCommandResponse qwpcr = new QueryWlParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length >= 9 && data.length % 7 == 2) {
// int n = (data.length - 2) / 7; // n表示水位点个数
// List<List<Double>> wlParams = new ArrayList<List<Double>>(n);
//
// // 解析多个水位点的值
// for (int i = 0; i < n; i++) {
// List<Double> item = new ArrayList<Double>();
//
// String benchmark = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 7 + 2] & 0x7F), data[i * 7 + 1], data[i * 7 + 0] });
// String lower = ByteUtil.bcdToString(new byte[] { data[i * 7 + 4], data[i * 7 + 3] });
// String upper = ByteUtil.bcdToString(new byte[] { data[i * 7 + 6], data[i * 7 + 5] });
//
// if (benchmark.equals("") == false && lower.equals("") == false && upper.equals("") == false) {
// // 判断剩余水量正负符号
// if ((data[i * 7 + 2] & 0x80) == 0x80) {
// item.add(0, Double.valueOf(Integer.parseInt(benchmark) * -0.01));
// } else {
// item.add(0, Double.valueOf(Integer.parseInt(benchmark) * 0.01));
// }
// item.add(1, Double.valueOf(Integer.parseInt(upper) * 0.01));
// item.add(2, Double.valueOf(Integer.parseInt(lower) * 0.01));
//
// wlParams.add(item);
// }
// }
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] { data[data.length - 1], data[data.length - 2] });
// qwpcr.setStatus(status);
// qwpcr.setWlParams(wlParams);
// qwpcr.setValid(true);
//
// } else {
// logger.error("查询水位参数命令响应数据域长度错误");
// qwpcr.setValid(false);
// }
//
// return qwpcr;
// }
//
// /**
// * 将设置终端水压参数响应消息字节数组解析为消息对象AFN=18H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetWpParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetWpParamCommandResponse swpcr = new SetWpParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length >= 8 && data.length % 8 == 0) {
// int n = data.length / 8; // n表示水压点个数
// List<List<Double>> wpParams = new ArrayList<List<Double>>(n);
//
// // 解析多个水压点的值
// for (int i = 0; i < n; i++) {
// List<Double> item = new ArrayList<Double>();
//
// String upper = ByteUtil.bcdToString(new byte[] { data[i * 8 + 3], data[i * 8 + 2], data[i * 8 + 1], data[i * 8 + 0] });
// String lower = ByteUtil.bcdToString(new byte[] { data[i * 8 + 7], data[i * 8 + 6], data[i * 8 + 5], data[i * 8 + 4] });
//
// if (lower.equals("") == false && upper.equals("") == false) {
// item.add(0, Double.valueOf(Integer.parseInt(upper) * 0.01));
// item.add(1, Double.valueOf(Integer.parseInt(lower) * 0.01));
//
// wpParams.add(item);
// }
// }
//
// swpcr.setWpParams(wpParams);
// swpcr.setValid(true);
// swpcr.setSuccess(true);
// } else {
// logger.error("设置水压参数命令响应数据域长度错误");
// swpcr.setValid(false);
// }
//
// return swpcr;
// }
//
// /**
// * 将查询终端水压参数响应消息字节数组解析为消息对象AFN=58H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryWpParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryWpParamCommandResponse qwpcr = new QueryWpParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length >= 10 && data.length % 8 == 2) {
// int n = (data.length - 2) / 8; // n表示水压点个数
// List<List<Double>> wpParams = new ArrayList<List<Double>>(n);
//
// // 解析多个水压点的值
// for (int i = 0; i < n; i++) {
// List<Double> item = new ArrayList<Double>();
//
// String upper = ByteUtil.bcdToString(new byte[] { data[i * 8 + 3], data[i * 8 + 2], data[i * 8 + 1], data[i * 8 + 0] });
// String lower = ByteUtil.bcdToString(new byte[] { data[i * 8 + 7], data[i * 8 + 6], data[i * 8 + 5], data[i * 8 + 4] });
//
// if (lower.equals("") == false && upper.equals("") == false) {
// item.add(0, Double.valueOf(Integer.parseInt(upper) * 0.01));
// item.add(1, Double.valueOf(Integer.parseInt(lower) * 0.01));
//
// wpParams.add(item);
// }
// }
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] { data[data.length - 1], data[data.length - 2] });
// qwpcr.setStatus(status);
// qwpcr.setWpParams(wpParams);
// qwpcr.setValid(true);
// } else {
// logger.error("查询水压参数命令响应数据域长度错误");
// qwpcr.setValid(false);
// }
//
// return qwpcr;
// }
//
// /**
// * 将设置终端水压参数响应消息字节数组解析为消息对象AFN=19H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetWqUpperParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetWqUpperParamCommandResponse swpcr = new SetWqUpperParamCommandResponse(Calendar.getInstance(), address);
// Map<String, String> wqNewParams = new HashMap<String, String>();
//
// // 解析并设置数据域
// if (data.length >= 5) {
// String indexBin = ByteUtil.binToBinString(new byte[] { data[4], data[3], data[2], data[1], data[0] }).substring(5); // D35-D39备用
// int len = indexBin.length();
// int j = 5; // data[j]
// for (int i = 0; i < len; i++) {
// if (indexBin.substring(len - 1 - i, len - i).equals("1")) {
// String[] format = Configure.getProperty("FD" + i, "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
// String valueStr = "";
// if (dt <= 8) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 4;
// } else if (dt == 10) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 4], data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 5;
// }
//
// String key = "D" + i;
// double value = Integer.parseInt(valueStr) * Math.pow(0.1, dd);
//
// // 输出格式
// String pattern = "";
// if (dd == 0) {
// pattern = "0";
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// }
// valueStr = NumberFormat.format(value, pattern);
//
// // 添加解析结果
// wqNewParams.put(key, valueStr);
// }
// }
// swpcr.setWqNewParams(wqNewParams);
//
// swpcr.setValid(true);
// swpcr.setSuccess(true);
// } else {
// swpcr.setValid(false);
// }
//
// return swpcr;
// }
//
// /**
// * 将设置终端水压参数响应消息字节数组解析为消息对象AFN=1AH
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetWqLowerParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetWqLowerParamCommandResponse swpcr = new SetWqLowerParamCommandResponse(Calendar.getInstance(), address);
// Map<String, String> wqNewParams = new HashMap<String, String>();
//
// // 解析并设置数据域
// if (data.length >= 5) {
// String indexBin = ByteUtil.binToBinString(new byte[] { data[4], data[3], data[2], data[1], data[0] }).substring(5); // D35-D39备用
// int len = indexBin.length();
// int j = 5; // data[j]
// for (int i = 0; i < len; i++) {
// if (indexBin.substring(len - 1 - i, len - i).equals("1")) {
// String[] format = Configure.getProperty("FD" + i, "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
// String valueStr = "";
// if (dt <= 8) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 4;
// } else if (dt == 10) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 4], data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 5;
// }
//
// String key = "D" + i;
// double value = Integer.parseInt(valueStr) * Math.pow(0.1, dd);
//
// // 输出格式
// String pattern = "";
// if (dd == 0) {
// pattern = "0";
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// }
// valueStr = NumberFormat.format(value, pattern);
//
// // 添加解析结果
// wqNewParams.put(key, valueStr);
// }
// }
// swpcr.setWqNewParams(wqNewParams);
//
// swpcr.setValid(true);
// swpcr.setSuccess(true);
// } else {
// swpcr.setValid(false);
// }
//
// return swpcr;
// }
//
// /**
// * 将查询终端水压参数上限响应消息字节数组解析为消息对象AFN=59H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryWqUpperParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryWqUpperParamCommandResponse qwpcr = new QueryWqUpperParamCommandResponse(Calendar.getInstance(), address);
// Map<String, String> wqParams = new HashMap<String, String>();
//
// // 解析并设置数据域
// if (data.length >= 5) {
// String indexBin = ByteUtil.binToBinString(new byte[] { data[4], data[3], data[2], data[1], data[0] }).substring(5); // D35-D39备用
// int len = indexBin.length();
// int j = 5; // data[j]
// for (int i = 0; i < len; i++) {
// if (indexBin.substring(len - 1 - i, len - i).equals("1")) {
// String[] format = Configure.getProperty("FD" + i, "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
// String valueStr = "";
// if (dt <= 8) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 4;
// } else if (dt == 10) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 4], data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 5;
// }
//
// String key = "D" + i;
// double value = Integer.parseInt(valueStr) * Math.pow(0.1, dd);
//
// // 输出格式
// String pattern = "";
// if (dd == 0) {
// pattern = "0";
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// }
// valueStr = NumberFormat.format(value, pattern);
//
// // 添加解析结果
// wqParams.put(key, valueStr);
// }
// }
//
// qwpcr.setValid(true);
// qwpcr.setWqParams(wqParams);
// } else {
// qwpcr.setValid(false);
// }
//
// return qwpcr;
// }
//
// /**
// * 将查询终端水压参数下限响应消息字节数组解析为消息对象AFN=5AH
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryWqLowerParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryWqLowerParamCommandResponse qwpcr = new QueryWqLowerParamCommandResponse(Calendar.getInstance(), address);
// Map<String, String> wqParams = new HashMap<String, String>();
//
// // 解析并设置数据域
// if (data.length >= 5) {
// String indexBin = ByteUtil.binToBinString(new byte[] { data[4], data[3], data[2], data[1], data[0] }).substring(5); // D35-D39备用
// int len = indexBin.length();
// int j = 5; // data[j]
// for (int i = 0; i < len; i++) {
// if (indexBin.substring(len - 1 - i, len - i).equals("1")) {
// String[] format = Configure.getProperty("FD" + i, "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
// String valueStr = "";
// if (dt <= 8) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 4;
// } else if (dt == 10) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 4], data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 5;
// }
//
// String key = "D" + i;
// double value = Integer.parseInt(valueStr) * Math.pow(0.1, dd);
//
// // 输出格式
// String pattern = "";
// if (dd == 0) {
// pattern = "0";
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// }
// valueStr = NumberFormat.format(value, pattern);
//
// // 添加解析结果
// wqParams.put(key, valueStr);
// }
// }
//
// qwpcr.setValid(true);
// qwpcr.setWqParams(wqParams);
// } else {
// qwpcr.setValid(false);
// }
//
// return qwpcr;
// }
//
// /**
// * 将设置终端流量参数响应消息字节数组解析为消息对象AFN=1FH
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetWfParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = GBByteFrameTool.getDataWithoutPwTp(gbFrame); // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetWfParamCommandResponse swpcr = new SetWfParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length % 5 == 0) {
// int n = data.length / 5;// 流量点个数
// List<Double> uppers = new ArrayList<Double>(n);
//
// // 解析多个流量点的值
// for (int i = 0; i < n; i++) {
// String upper = ByteUtil.bcdToString(new byte[] { data[i * 5 + 4], data[i * 5 + 3], data[i * 5 + 2], data[i * 5 + 1], data[i * 5] });
// if (upper.equals("") == false) {
// if ((data[i * 5 + 4] & 0xF0) == 0xF0)// 判断正负
// uppers.add(Double.valueOf(Integer.parseInt(upper) * -0.001));
// else
// uppers.add(Double.valueOf(Integer.parseInt(upper) * 0.001));
// }
// }
//
// swpcr.setNewUppers(uppers);
// swpcr.setValid(true);
// swpcr.setSuccess(true);
// } else {
// swpcr.setValid(false);
// }
//
// return swpcr;
// }
//
// /**
// * 将查询终端流量参数响应消息字节数组解析为消息对象AFN=64H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryWfParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryWfParamCommandResponse qwpcr = new QueryWfParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length >= 7 && data.length % 5 == 2) {
// int n = (data.length - 2) / 5;// 流量点个数
// List<Double> uppers = new ArrayList<Double>(n);
//
// // 解析多个流量点的值
// for (int i = 0; i < n; i++) {
// String upper = ByteUtil.bcdToString(new byte[] { data[i * 5 + 4], data[i * 5 + 3], data[i * 5 + 2], data[i * 5 + 1], data[i * 5] });
// if (upper.equals("") == false) {
// if ((data[i * 5 + 4] & 0xF0) == 0xF0)// 判断正负
// uppers.add(Double.valueOf(Integer.parseInt(upper) * -0.001));
// else
// uppers.add(Double.valueOf(Integer.parseInt(upper) * 0.001));
// }
// }
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] { data[data.length - 1], data[data.length - 2] });
// qwpcr.setStatus(status);
// qwpcr.setUppers(uppers);
// qwpcr.setValid(true);
// } else {
// qwpcr.setValid(false);
// }
//
// return qwpcr;
// }
//
// /**
// * 将设置终端水量表底值响应消息字节数组解析为消息对象AFN=1BH
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetFlowInitCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetFlowInitCommandResponse sficr = new SetFlowInitCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length % 5 == 0) {
// int n = data.length / 5; //监测点个数
// List<Long> inits = new ArrayList<Long>(n);
//
// // 解析多个监测点的值
// for (int i = 0; i < n; i++) {
// String init = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 5 + 4]), data[i * 5 + 3], data[i * 5 + 2], data[i * 5 + 1], data[i * 5] });
//
// inits.add(Long.valueOf(init));
// }
// sficr.setNewInits(inits);
//
// sficr.setValid(true);
// sficr.setSuccess(true);
// } else {
// sficr.setValid(false);
// }
//
// return sficr;
// }
//
// /**
// * 将设置终端启报阈值及存储时间段间隔响应消息字节数组解析为消息对象AFN=20H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetThresholdCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetThresholdCommandResponse stcr = new SetThresholdCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length >= 3) {
// int type = ByteUtil.binToInt(data[0], 7, 4);
// int no = ByteUtil.binToInt(data[0], 3, 0);
// int inter = data[1];
// double thresh = 0.0;
//
// stcr.setType(type);
// stcr.setNo(no);
// stcr.setInter(inter);
//
// switch (type) {
// case 0: //雨量参数
// stcr.setThresh(ByteUtil.bcdToInt(data[2])/10.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 1: //水位参数
// if (data.length == 6) {
// thresh = ByteUtil.bcdToLong(new byte[] {(byte) (data[5] & 0x0F), data[4], data[3], data[2]});
// if ((data[5] & 0xF0) == 0xF0)
// thresh = thresh * -1;
// }
// stcr.setThresh(thresh / 1000.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 2: //水量参数
// if (data.length == 7) {
// thresh = ByteUtil.bcdToLong(new byte[] {(byte) (data[6] & 0x7F), data[5], data[4], data[3], data[2]});
// if ((data[6] & 0x80) == 0x80)
// thresh = thresh * -1;
// }
// stcr.setThresh(thresh);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 3: //流速参数
// if (data.length == 5) {
// thresh = ByteUtil.bcdToLong(new byte[] {(byte) (data[4] & 0x0F), data[3], data[2]});
// if ((data[4] & 0xF0) == 0xF0)
// thresh = thresh * -1;
// }
// stcr.setThresh(thresh / 1000.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 4: //闸位参数
// if (data.length == 5) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[4], data[3], data[2]});
// }
// stcr.setThresh(thresh / 100.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 5: //功率参数
// if (data.length == 5) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[4], data[3], data[2]});
// }
// stcr.setThresh(thresh);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 6: //气压参数
// if (data.length == 5) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[4], data[3], data[2]});
// }
// stcr.setThresh(thresh);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 7: //风速参数
// if (data.length == 5) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[4], data[3], data[2]});
// }
// stcr.setThresh(thresh / 100.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 8: //水温参数
// if (data.length == 4) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[3], data[2]});
// }
// stcr.setThresh(thresh / 10.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 10: //土壤含水率参数
// if (data.length == 4) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[3], data[2]});
// }
// stcr.setThresh(thresh / 10.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 11: //蒸发量参数
// if (data.length == 5) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[4], data[3], data[2]});
// }
// stcr.setThresh(thresh / 10.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// case 12: //水压参数
// if (data.length == 6) {
// thresh = ByteUtil.bcdToLong(new byte[] {data[5], data[4], data[3], data[2]});
// }
// stcr.setThresh(thresh / 100.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// break;
//
// default:
// stcr.setThresh(0.0);
// stcr.setValid(true);
// stcr.setSuccess(true);
// }
// } else {
// stcr.setValid(false);
// }
//
// return stcr;
// }
//
// /**
// * 将设置终端定值量响应消息字节数组解析为消息对象AFN=34H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetFixedValueCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetFixedValueCommandResponse sfvcr = new SetFixedValueCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 5) {
// String fixed = ByteUtil.bcdToString(new byte[] {(byte) (data[4]), data[3], data[2], data[1], data[0]});
//
// sfvcr.setFixedValue(Long.parseLong(fixed));
//
// sfvcr.setValid(true);
// sfvcr.setSuccess(true);
// } else {
// sfvcr.setValid(false);
// }
//
// return sfvcr;
// }
//
// /**
// * 将修改终端密码响应消息字节数组解析为消息对象AFN=96H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSetPasswordCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// SetPasswordCommandResponse spcr = new SetPasswordCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 2) {
// spcr.setValid(true);
// spcr.setSuccess(true);
// spcr.setNewPassword((int) ByteUtil.bcdToLong(new byte[] {data[1], data[0]}));
// } else {
// spcr.setValid(false);
// }
//
// return spcr;
// }
//
// /**
// * 将查询终端实时值命令响应消息字节数组解析为消息对象AFN=B0H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryRealTimeValueCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryRealTimeValueCommandResponse qrtvcr = new QueryRealTimeValueCommandResponse(Calendar.getInstance(), address);
// qrtvcr.setRttype(gbFrame.FRAME_CONTROL_FN);
//
// // 解析并设置数据域
// switch (gbFrame.FRAME_CONTROL_FN) {
// case GBConstants.CTRL_DIR1_RESP:
// return qrtvcr;
// case GBConstants.CTRL_DIR1_MRF:// 雨量参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { data[2], data[1], data[0] });
// try { // 判断如果有超大数字则置0
// qrtvcr.setResults(String.valueOf(Integer.parseInt(rt) / 10.0));
// } catch (Exception e) {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MWL:// 水位参数
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 4 + 3] & 0x0F), data[i * 4 + 2], data[i * 4 + 1], data[i * 4] });
// try { // 判断如果有超大数字则置0
// // 判断正负
// if ((data[i * 4 + 3] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MACC:// 流量（水量）参数
// if (data.length >= 9 && data.length % 5 == 4) {
// int n = (data.length - 4) / 5;// 水量仪表数
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 5 + 4] & 0x7F), data[i * 5 + 3], data[i * 5 + 2], data[i * 5 + 1], data[i * 5] });
// try { // 判断如果有超大数字则置0
// // 判断正负
// if ((data[i * 5 + 4] & 0x80) == 0x80)
// results += String.valueOf(Long.parseLong(rt) * -1) + ",";
// else
// results += String.valueOf(Long.parseLong(rt)) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MFV:// 流速参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 流速仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// try { // 判断如果有超大数字则置0
// // 判断正负
// if ((data[i * 3 + 2] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MBC:// 闸位参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 闸位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// try { // 判断如果有超大数字则置0
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MPW:// 功率参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 功率仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {data[i * 3 + 2], data[i * 3 + 1], data[i * 3] });
// try { // 判断如果有超大数字则置0
// results += String.valueOf(Integer.parseInt(rt)) + ",";
// } catch (Exception e) {
// results += "0"+ ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MAP:// 气压参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[2] & 0x0F), data[1], data[0] });
// try { // 判断如果有超大数字则置0
// qrtvcr.setResults(String.valueOf(Integer.parseInt(rt)));
// } catch (Exception e) {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MWS:// 风速参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[2] & 0x0F), data[1], data[0] });
// try { // 判断如果有超大数字则置0
// String results = "";
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// results += String.valueOf(Integer.parseInt(ByteUtil.bcdToString(new byte[] { (byte) ((data[2] & 0xF0) >> 4) })));
// qrtvcr.setResults(results);
// break;
// } catch (Exception e) {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MWT:// 水温参数
// if (data.length == 6) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[1] & 0x0F), data[0] });
// try { // 判断如果有超大数字则置0
// qrtvcr.setResults(String.valueOf(Integer.parseInt(rt) / 10.0));
// break;
// } catch (Exception e) {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MWQ:// 水质参数
// break;
//
// case GBConstants.CTRL_DIR1_MSA:// 土壤含水率参数
// if (data.length >= 6 && (data.length - 4) % 2 == 0) {
// int n = (data.length - 4) / 2;// 土壤含水率仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {data[i * 2 + 1], data[i * 2] });
// try { // 判断如果有超大数字则置0
// results += String.valueOf(Integer.parseInt(rt) / 10.0) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MVQ:// 蒸发量参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 蒸发量仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// try { // 判断如果有超大数字则置0
// results += String.valueOf(Integer.parseInt(rt) / 10.0) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// case GBConstants.CTRL_DIR1_MHP:// 水压参数
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水压仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {data[i * 4 + 3], data[i * 4 + 2], data[i * 4 + 1], data[i * 4] });
// try { // 判断如果有超大数字则置0
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// } catch (Exception e) {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// qrtvcr.setResults(results);
// break;
// } else {
// qrtvcr.setValid(false);
// return qrtvcr;
// }
// }
// // 解析并设置终端报警数据
// String warn = ByteUtil.binToBinString(new byte[] {data[data.length - 3], data[data.length - 4] });
// qrtvcr.setWarn(warn);
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] {data[data.length - 1], data[data.length - 2] });
// qrtvcr.setStatus(status);
//
// qrtvcr.setValid(true);
// return qrtvcr;
// }
//
// /**
// * 将查询终端实时状态命令响应消息字节数组解析为消息对象AFN=5EH
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryRealTimeStatusCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryRealTimeStatusCommandResponse qrtscr = new QueryRealTimeStatusCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 4) {
// // 解析并设置终端报警数据
// String warn = ByteUtil.binToBinString(new byte[] { data[1], data[0] });
// qrtscr.setWarn(warn);
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] { data[3], data[2] });
// qrtscr.setStatus(status);
//
// qrtscr.setValid(true);
// } else {
// qrtscr.setValid(false);
// }
//
// return qrtscr;
// }
//
// /**
// * 将定时自报消息字节数组解析为消息对象AFN=C0H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToTimingDataMessage(GBByteFrame gbFrame) {
// String address = gbFrame.address; // 获取地址域
//
// TimingDataMessage tdm = new TimingDataMessage(Calendar.getInstance(), address);
//
// // 先处理时标
// byte[] bt = new byte[4];
// for (int i = 0; i < bt.length; i++) {
// bt[i] = gbFrame.FRAME_DATA_BODY[gbFrame.FRAME_DATA_BODY.length - 1 - bt.length + i];
// }
//
// // TP中的秒分时日
// int second = ByteUtil.bcdToInt(bt[bt.length - 4]);
// int minute = ByteUtil.bcdToInt(bt[bt.length - 3]);
// int hour = ByteUtil.bcdToInt(bt[bt.length - 2]);
// int date = ByteUtil.bcdToInt(bt[bt.length - 1]);
//
// Calendar tp = null;
// try {
// tp = GBByteFrameTool.getTp(gbFrame);
//
// if (date == tdm.getTime().get(Calendar.DAY_OF_MONTH)) {
// /**
// * 日期与当前日期相同
// * 表示为最近的自报消息
// * 判断是否超前
// * 不超前即认为是正常自报或当日的补报
// */
// if (tp.getTimeInMillis() - tdm.getTime().getTimeInMillis() > 1000 * 60 * 30) {
// System.out.println("定时自报消息时标超前"); // 超前半小时以上
// logger.error("定时自报消息时标超前");
// tdm.setValid(false);
//
// return tdm;
// }
//
// tdm.setTime(tp);
// }
// else if (date > tdm.getTime().get(Calendar.DAY_OF_MONTH)) {
// /**
// * 日期大于当前日期
// * 表示可能为上月的补报自报消息
// * 将月份减1
// */
// try {
// tp.setLenient(false);
//
// tp.add(Calendar.MONTH, -1);
// tp.set(Calendar.DAY_OF_MONTH, date);
// tp.set(Calendar.HOUR_OF_DAY, hour);
// tp.set(Calendar.MINUTE, minute);
// tp.set(Calendar.SECOND, second);
//
// tp.getTimeInMillis();
//
// tdm.setTime(tp);
// } catch (Exception e) {
// System.out.println("定时自报消息时标解析异常");
// logger.error("定时自报消息时标解析异常");
// tdm.setValid(false);
//
// return tdm;
// }
// }
// else {
// /**
// * 日期小于当前日期
// * 认为是当月的补报自报消息
// * 月份不变
// */
// tdm.setTime(tp);
// }
// } catch (Exception re) {
// /**
// * 判断是否是日期为31导致的错误
// * 将月份减1
// */
// try {
// tp = Calendar.getInstance();
// tp.setLenient(false);
//
// tp.add(Calendar.MONTH, -1);
// tp.set(Calendar.DAY_OF_MONTH, date);
// tp.set(Calendar.HOUR_OF_DAY, hour);
// tp.set(Calendar.MINUTE, minute);
// tp.set(Calendar.SECOND, second);
//
// tp.getTimeInMillis();
//
// tdm.setTime(tp);
// } catch (Exception e) {
// System.out.println("定时自报消息时标解析异常");
// logger.error("定时自报消息时标解析异常");
// tdm.setValid(false);
//
// return tdm;
// }
// }
//
// tdm.setTime(tp);
// tdm.setFcb(gbFrame.FRAME_CONTROL_FCB);
// tdm.setAfn(gbFrame.FRAME_DATA_AFN);
// tdm.setType(gbFrame.FRAME_CONTROL_FN);
//
// byte[] data = GBByteFrameTool.getDataWithoutAfnTp(gbFrame); // 获取数据域
//
// switch (gbFrame.FRAME_CONTROL_FN) {
// case GBConstants.CTRL_DIR1_RESP:
// return tdm;
// case GBConstants.CTRL_DIR1_MRF:// 雨量参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { data[2], data[1], data[0] });
// if (rt.equals("") ==false) {
// tdm.setResults(String.valueOf(Integer.parseInt(rt) / 10.0));
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MWL:// 水位参数
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] {(byte) (data[i * 4 + 3] & 0x0F), data[i * 4 + 2], data[i * 4 + 1], data[i * 4] });
// if (rt.equals("") == false) {
// // 判断正负
// if ((data[i * 4 + 3] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// } else {
// results += "-1" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MACC:// 流量（水量）参数
// if (data.length >= 9 && data.length % 5 == 4) {
// int n = (data.length - 4) / 5;// 水量仪表数
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 5 + 4] & 0x7F), data[i * 5 + 3], data[i * 5 + 2], data[i * 5 + 1], data[i * 5] });
// if (rt.equals("")) {
// results += "-1" + ",";
// continue;
// }
//
// // 判断正负
// if ((data[i * 5 + 4] & 0x80) == 0x80)
// results += String.valueOf(Long.parseLong(rt) * -1) + ",";
// else
// results += String.valueOf(Long.parseLong(rt)) + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MFV:// 流速参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 流速仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// if (rt.equals("")) {
// results += "-1" + ",";
// continue;
// }
//
// // 判断正负
// if ((data[i * 3 + 2] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MBC:// 闸位参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 闸位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// if (rt.equals("")) {
// results += "-1" + ",";
// continue;
// }
//
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MPW:// 功率参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 功率仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { data[i * 3 + 2], data[i * 3 + 1], data[i * 3] });
// if (rt.equals("")) {
// results += "-1" + ",";
// continue;
// }
//
// results += String.valueOf(Integer.parseInt(rt)) + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MAP:// 气压参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[2] & 0x0F), data[1], data[0] });
// if (rt.equals("") == true) {
// tdm.setValid(false);
// return tdm;
// }
// tdm.setResults(String.valueOf(Integer.parseInt(rt)));
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MWS:// 风速参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[2] & 0x0F), data[1], data[0] });
// if (rt.equals("") == true) {
// tdm.setValid(false);
// return tdm;
// }
// String results = "";
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// results += String.valueOf(Integer.parseInt(ByteUtil.bcdToString(new byte[] { (byte) ((data[2] & 0xF0) >> 4) })));
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MWT:// 水温参数
// if (data.length == 6) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[1] & 0x0F), data[0] });
// if (rt.equals("") == true ) {
// tdm.setValid(false);
// return tdm;
// }
// tdm.setResults(String.valueOf(Integer.parseInt(rt) / 10.0));
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MWQ:// 水质参数
// break;
//
// case GBConstants.CTRL_DIR1_MSA:// 土壤含水率参数
// if (data.length >= 6 && (data.length - 4) % 2 == 0) {
// int n = (data.length - 4) / 2;// 土壤含水率仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { data[i * 2 + 1], data[i * 2] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 10.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MVQ:// 蒸发量参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 蒸发量仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 10.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MSS:// 报警或状态参数
// if (data.length == 4)
// break;
// else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MHRF:// 统计雨量
// if (data.length == 8) {
// String results = "";
// if (((data[0] & 0xC0) >> 6) == 0)
// results += "00,";// 步长5分钟
// else if (((data[0] & 0xC0) >> 6) == 1)
// results += "01,";// 步长1小时
// else if (((data[0] & 0xC0) >> 6) == 2)
// results += "10,";// 步长1天
// else
// results += "11,";// 测试数据
// results += (data[0] & 0x3F) + ",";// 时段长度
// String rt = ByteUtil.bcdToString(new byte[] { data[3], data[2], data[1] });
// if (rt.equals("") == true) {
// tdm.setValid(false);
// return tdm;
// }
// results += String.valueOf(Integer.parseInt(rt) / 10.0);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// case GBConstants.CTRL_DIR1_MHP:// 水压参数
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水压仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { data[i * 4 + 3], data[i * 4 + 2], data[i * 4 + 1], data[i * 4] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// tdm.setResults(results);
// break;
// } else {
// tdm.setValid(false);
// return tdm;
// }
// }
//
// // 解析并设置终端报警数据
// String warn = ByteUtil.binToBinString(new byte[] { data[data.length - 3], data[data.length - 4] });
// tdm.setWarn(warn);
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] { data[data.length - 1], data[data.length - 2] });
// tdm.setStatus(status);
//
// tdm.setValid(true);
//
// return tdm;
// }
//
// /**
// * 将随机报警消息字节数组解析为消息对象AFN=81H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToWarningMessage(GBByteFrame gbFrame) {
// String address = gbFrame.address; // 获取地址域
//
// WarningMessage wm = new WarningMessage(Calendar.getInstance(), address);
//
// // 计算时间延迟是否超过许可时间
// Calendar tp = null;
// int tpDelay = GBByteFrameTool.getTpDelay(gbFrame);
// try {
// tp = GBByteFrameTool.getTp(gbFrame);
// } catch (Exception re) {
// System.out.println("随机报警消息时标解析异常");
// logger.error("随机报警消息时标解析异常");
// wm.setValid(false);
// }
// if (tp.getTimeInMillis() - wm.getTime().getTimeInMillis() > 1000 * 60 * 30) {
// System.out.println("随机报警消息时标超前"); // 超前半小时以上
// logger.error("随机报警消息时标超前");
// wm.setValid(false);
// } else if (tpDelay != 0
// && (wm.getTime().getTimeInMillis() - tp.getTimeInMillis()) > tpDelay * 60 * 1000) {
// System.out.println("随机报警消息超时");
// logger.error("随机报警消息超时");
// wm.setValid(false);
// } else {
// wm.setTime(tp);
// wm.setFcb(gbFrame.FRAME_CONTROL_FCB);
// wm.setAfn(gbFrame.FRAME_DATA_AFN);
// wm.setType(gbFrame.FRAME_CONTROL_FN);
//
// byte[] data = GBByteFrameTool.getDataWithoutAfnTp(gbFrame); // 获取数据域
// // 解析并设置报警状态
// String warn = "";
// warn = ByteUtil.binToBinString(new byte[] { data[1], data[0] });
// wm.setWarn(warn);
// // 解析并设置数据域
// switch (gbFrame.FRAME_CONTROL_FN) {
// case GBConstants.CTRL_DIR1_RESP:
// return wm;
// case GBConstants.CTRL_DIR1_MWL:// 水位超限
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 4 + 5] & 0x0F), data[i * 4 + 4], data[i * 4 + 3], data[i * 4 + 2] });
// if (rt.equals("") == false) {
// // 判断正负
// if ((data[i * 4 + 5] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// } else {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// wm.setResults(results);
// break;
// } else {
// wm.setValid(false);
// return wm;
// }
// case GBConstants.CTRL_DIR1_MACC:// 流量（水量）超限
// if (data.length >= 9 && data.length % 5 == 4) {
// int n = (data.length - 4) / 5;// 水量仪表数
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 5 + 6] & 0x7F), data[i * 5 + 5], data[i * 5 + 4], data[i * 5 + 3], data[i * 5 + 2] });
// if (rt.equals("") == false) {
// // 判断正负
// if ((data[i * 5 + 6] & 0x80) == 0x80)
// results += String.valueOf(Long.parseLong(rt) * -1) + ",";
// else
// results += String.valueOf(Long.parseLong(rt)) + ",";
// } else {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// wm.setResults(results);
// break;
// } else {
// wm.setValid(false);
// return wm;
// }
// case GBConstants.CTRL_DIR1_MWQ:// 水质超限
// if (data.length >= 5) {
// String indexBin = ByteUtil.binToBinString(new byte[] { data[6], data[5], data[4], data[3], data[2] }).substring(5); // D35-D39备用
// String results = "";
// int len = indexBin.length();
// int j = 7;
// for (int i = 0; i < len; i++) {
// if (indexBin.substring(len - 1 - i, len - i).equals("1")) {
// String[] format = Configure.getProperty("FD" + i, "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
// String valueStr = "";
// if (dt <= 8) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 4;
// } else if (dt == 10) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 4], data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 5;
// }
// String key = "D" + i;
// if (valueStr.equals("") == false) {
// double value = Integer.parseInt(valueStr) * Math.pow(0.1, dd);
// // 输出格式
// String pattern = "";
// if (dd == 0) {
// pattern = "0";
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// }
// valueStr = NumberFormat.format(value, pattern);
// } else {
// valueStr = "0.0";
// }
// results += key + "," + valueStr + ";";
// }
// }
// results = results.substring(0, results.length() - 1);
// wm.setResults(results);
// break;
// } else {
// wm.setValid(false);
// return wm;
// }
// default:
// if (data.length == 4)
// break;
// else {
// wm.setValid(false);
// return wm;
// }
// }
//
// String status = "";
// status = ByteUtil.binToBinString(new byte[] { data[data.length - 1], data[data.length - 2] });
// wm.setStatus(status);
// wm.setValid(true);
// }
//
// return wm;
// }
//
// /**
// * 将人工置数消息字节数组解析为消息对象AFN=C0H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToSettingDataMessage(GBByteFrame gbFrame) {
// String address = gbFrame.address; // 获取地址域
//
// SettingDataMessage sdm = new SettingDataMessage(Calendar.getInstance(), address);
//
// // 计算时间延迟是否超过许可时间
// Calendar tp = null;
// int tpDelay = GBByteFrameTool.getTpDelay(gbFrame);
// try {
// tp = GBByteFrameTool.getTp(gbFrame);
// } catch (Exception re) {
// System.out.println("人工置数消息时标解析异常");
// logger.error("人工置数消息时标解析异常");
// sdm.setValid(false);
// }
// if (tp.getTimeInMillis() - sdm.getTime().getTimeInMillis() > 1000 * 60 * 30) {
// System.out.println("人工置数消息时标超前"); // 超前半小时以上
// logger.error("人工置数消息时标超前");
// sdm.setValid(false);
// } else if (tpDelay != 0 && (sdm.getTime().getTimeInMillis() - tp.getTimeInMillis()) > tpDelay * 60 * 1000) {
// System.out.println("人工置数消息超时");
// logger.error("人工置数消息超时");
// sdm.setValid(false);
// } else {
// sdm.setTime(tp);
// sdm.setFcb(gbFrame.FRAME_CONTROL_FCB);
// sdm.setAfn(gbFrame.FRAME_DATA_AFN);
// sdm.setType(gbFrame.FRAME_CONTROL_FN);
//
// byte[] data = GBByteFrameTool.getDataWithoutAfnTp(gbFrame); // 获取数据域
// // 解析并设置数据域
// switch (gbFrame.FRAME_CONTROL_FN) {
// case GBConstants.CTRL_DIR1_RESP:
// return sdm;
// case GBConstants.CTRL_DIR1_MRF:// 雨量参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { data[2], data[1], data[0] });
// if (rt.equals("") == true) {
// sdm.setValid(false);
// return sdm;
// }
// sdm.setResults(String.valueOf(Integer.parseInt(rt) / 10.0));
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MWL:// 水位参数
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 4 + 3] & 0x0F), data[i * 4 + 2], data[i * 4 + 1], data[i * 4] });
// if (rt.equals("") == false) {
// // 判断正负
// if ((data[i * 4 + 3] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// } else {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MACC:// 流量（水量）参数
// if (data.length >= 9 && data.length % 5 == 4) {
// int n = (data.length - 4) / 5;// 水量仪表数
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 5 + 4] & 0x7F), data[i * 5 + 3], data[i * 5 + 2], data[i * 5 + 1], data[i * 5] });
// if (rt.equals("") == false) {
// // 判断正负
// if ((data[i * 5 + 4] & 0x80) == 0x80)
// results += String.valueOf(Long.parseLong(rt) * -1) + ",";
// else
// results += String.valueOf(Long.parseLong(rt)) + ",";
// } else {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MFV:// 流速参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 流速仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// if (rt.equals("") == false) {
// // 判断正负
// if ((data[i * 3 + 2] & 0xf0) == 0xf0)
// results += String.valueOf(Integer.parseInt(rt) / -1000.0) + ",";
// else
// results += String.valueOf(Integer.parseInt(rt) / 1000.0) + ",";
// } else {
// results += "0" + ",";
// }
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MBC:// 闸位参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 闸位仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MPW:// 功率参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 功率仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { data[i * 3 + 2], data[i * 3 + 1], data[i * 3] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt)) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MAP:// 气压参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[2] & 0x0F), data[1], data[0] });
// if (rt.equals("") == true) {
// sdm.setValid(false);
// return sdm;
// }
// sdm.setResults(String.valueOf(Integer.parseInt(rt)));
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MWS:// 风速参数
// if (data.length == 7) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[2] & 0x0F), data[1], data[0] });
// if (rt.equals("") == true) {
// sdm.setValid(false);
// return sdm;
// }
// String results = "";
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// results += String.valueOf(Integer.parseInt(ByteUtil.bcdToString(new byte[] { (byte) ((data[2] & 0xF0) >> 4) })));
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MWT:// 水温参数
// if (data.length == 6) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[1] & 0x0F), data[0] });
// if (rt.equals("") == true) {
// sdm.setValid(false);
// return sdm;
// }
// sdm.setResults(String.valueOf(Integer.parseInt(rt) / 10.0));
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MWQ:// 水质参数
// if (data.length >= 5) {
// String indexBin = ByteUtil.binToBinString(new byte[] { data[4], data[3], data[2], data[1], data[0] }).substring(5); // D35-D39备用
// String results = "";
// int len = indexBin.length();
// int j = 5;
// for (int i = 0; i < len; i++) {
// if (indexBin.substring(len - 1 - i, len - i).equals("1")) {
// String[] format = Configure.getProperty("FD" + i, "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
// String valueStr = "";
// if (dt <= 8) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 4;
// } else if (dt == 10) {
// valueStr = ByteUtil.bcdToString(new byte[] { data[j + 4], data[j + 3], data[j + 2], data[j + 1], data[j] });
// j = j + 5;
// }
// String key = "D" + i;
// if (valueStr.equals("")) {
// double value = Integer.parseInt(valueStr) * Math.pow(0.1, dd);
// // 输出格式
// String pattern = "";
// if (dd == 0) {
// pattern = "0";
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// }
// valueStr = NumberFormat.format(value, pattern);
// } else {
// valueStr = "0.0";
// }
// results += key + "," + valueStr + ";";
// }
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MSA:// 土壤含水率参数
// if (data.length >= 6 && (data.length - 4) % 2 == 0) {
// int n = (data.length - 4) / 2;// 土壤含水率仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { data[i * 2 + 1], data[i * 2] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 10.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MVQ:// 蒸发量参数
// if (data.length >= 7 && (data.length - 4) % 3 == 0) {
// int n = (data.length - 4) / 3;// 蒸发量仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { (byte) (data[i * 3 + 2] & 0x0F), data[i * 3 + 1], data[i * 3] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 10.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MSS:// 报警或状态参数
// if (data.length == 4)
// break;
// else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MHRF:// 统计雨量
// if (data.length == 8) {
// String results = "";
// if (((data[0] & 0xC0) >> 6) == 0)
// results += "00,";// 步长5分钟
// else if (((data[0] & 0xC0) >> 6) == 1)
// results += "01,";// 步长1小时
// else if (((data[0] & 0xC0) >> 6) == 2)
// results += "10,";// 步长1天
// else
// results += "11,";// 测试数据
// results += (data[0] & 0x3F) + ",";// 时段长度
// String rt = ByteUtil.bcdToString(new byte[] { data[3], data[2], data[1] });
// if (rt.equals("") == true) {
// sdm.setValid(false);
// return sdm;
// }
// results += String.valueOf(Integer.parseInt(rt) / 10.0);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// case GBConstants.CTRL_DIR1_MHP:// 水压参数
// if (data.length >= 8 && data.length % 4 == 0) {
// int n = (data.length - 4) / 4;// 水压仪表数量
// String results = "";
// for (int i = 0; i < n; i++) {
// String rt = ByteUtil.bcdToString(new byte[] { data[i * 4 + 3], data[i * 4 + 2], data[i * 4 + 1], data[i * 4] });
// if (rt.equals("") == false)
// results += String.valueOf(Integer.parseInt(rt) / 100.0) + ",";
// else
// results += "0" + ",";
// }
// results = results.substring(0, results.length() - 1);
// sdm.setResults(results);
// break;
// } else {
// sdm.setValid(false);
// return sdm;
// }
// }
// // 解析并设置终端报警数据
// String warn = ByteUtil.binToBinString(new byte[] { data[data.length - 3], data[data.length - 4] });
// sdm.setWarn(warn);
//
// // 解析并设置终端状态
// String status = ByteUtil.binToBinString(new byte[] { data[data.length - 1], data[data.length - 2] });
// sdm.setStatus(status);
//
// sdm.setValid(true);
// }
//
// return sdm;
// }
//
// /**
// * 将设置终端IC卡有效功能命令响应消息字节数组解析为消息对象AFN=30H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToEnableICCardCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// EnableICCardCommandResponse eicccr = new EnableICCardCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if (data[0] == 0x5A) {
// eicccr.setSuccess(true);
// } else {
// eicccr.setSuccess(false);
// }
//
// eicccr.setValid(true);
// } else {
// eicccr.setValid(false);
// }
//
// return eicccr;
// }
//
// /**
// * 将设置终端IC卡功能无效命令响应消息字节数组解析为消息对象AFN=31H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToDisableICCardCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// DisableICCardCommandResponse dicccr = new DisableICCardCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if (data[0] == 0x5A) {
// dicccr.setSuccess(true);
// } else {
// dicccr.setSuccess(false);
// }
//
// dicccr.setValid(true);
// } else {
// dicccr.setValid(false);
// }
//
// return dicccr;
// }
//
// /**
// * 将设置终端定值控制投入功能命令响应消息字节数组解析为消息对象AFN=32H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToEnableFixedValCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// EnableFixedValCommandResponse efvcr = new EnableFixedValCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if (data[0] == 0x5A) {
// efvcr.setSuccess(true);
// } else {
// efvcr.setSuccess(false);
// }
//
// efvcr.setValid(true);
// } else {
// efvcr.setValid(false);
// }
//
// return efvcr;
// }
//
// /**
// * 将设置终端定值控制退出功能命令响应消息字节数组解析为消息对象AFN=33H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToDisableFixedValCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// DisableFixedValCommandResponse dfvcr = new DisableFixedValCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if (data[0] == 0x5A) {
// dfvcr.setSuccess(true);
// } else {
// dfvcr.setSuccess(false);
// }
//
// dfvcr.setValid(true);
// } else {
// dfvcr.setValid(false);
// }
//
// return dfvcr;
// }
//
// /**
// * 将遥控开启水泵/闸门命令响应消息字节数组解析为消息对象AFN=92H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToRemoteOpenPumpCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// RemoteOpenPumpCommandResponse ropcr = new RemoteOpenPumpCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if ((data[0] & 0xF0) == 0xA0) {
// ropcr.setSuccess(true);
// } else {
// ropcr.setSuccess(false);
// }
//
// ropcr.setValid(true);
// } else {
// ropcr.setValid(false);
// }
//
// return ropcr;
// }
//
// /**
// * 将遥控关闭水泵/闸门命令响应消息字节数组解析为消息对象AFN=93H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToRemoteClosePumpCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// RemoteClosePumpCommandResponse rcpcr = new RemoteClosePumpCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if ((data[0] & 0xF0) == 0xA0) {
// rcpcr.setSuccess(true);
// } else {
// rcpcr.setSuccess(false);
// }
//
// rcpcr.setValid(true);
// } else {
// rcpcr.setValid(false);
// }
//
// return rcpcr;
// }
//
// /**
// * 将复位终端参数命令响应消息字节数组解析为消息对象AFN=90H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToResetParamCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// ResetParamCommandResponse rpcr = new ResetParamCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if (data[0] == 0x5A) {
// rpcr.setSuccess(true);
// } else {
// rpcr.setSuccess(false);
// }
//
// rpcr.setValid(true);
// } else {
// rpcr.setValid(false);
// }
//
// return rpcr;
// }
//
// /**
// * 将清空终端历史数据单元命令响应消息字节数组解析为消息对象AFN=91H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToClearHistoryCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// ClearHistoryCommandResponse chcr = new ClearHistoryCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 1) {
// if (data[0] == 0x01 || data[0] == 0x02) {
// chcr.setSuccess(true);
// } else {
// chcr.setSuccess(false);
// }
//
// chcr.setValid(true);
// } else {
// chcr.setValid(false);
// }
//
// return chcr;
// }
//
// /**
// * 将查询水泵电机实时工作数据命令响应消息字节数解析为消息对象AFN=5FH
// *
// * @param message
// * @return
// */
// private AppMessage bytesToQueryRealTimeMotoValueCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryRealTimeMotoValueCommandResponse qrtmv = new QueryRealTimeMotoValueCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 12) {
// // 解析并设置A相电压
// int vaInt = ByteUtil.binToInt(new byte[] { data[1], data[0] });
// if (vaInt < 1000)
// qrtmv.setVoltageA(String.valueOf(vaInt));
// else
// qrtmv.setVoltageA("0");
//
// // 解析并设置B相电压
// int vbInt = ByteUtil.binToInt(new byte[] { data[3], data[2] });
// if (vbInt < 1000)
// qrtmv.setVoltageB(String.valueOf(vbInt));
// else
// qrtmv.setVoltageB("0");
//
// // 解析并设置C相电压
// int vcInt = ByteUtil.binToInt(new byte[] { data[5], data[4] });
// if (vcInt < 1000)
// qrtmv.setVoltageC(String.valueOf(vcInt));
// else
// qrtmv.setVoltageC("0");
//
// // 解析并设置A相电流
// int eaInt = ByteUtil.binToInt(new byte[] { data[7], data[6] });
// if (eaInt < 1000)
// qrtmv.setEcurrentA(String.valueOf(eaInt));
// else
// qrtmv.setEcurrentA("0");
//
// // 解析并设置B相电流
// int ebInt = ByteUtil.binToInt(new byte[] { data[9], data[8] });
// if (ebInt < 1000)
// qrtmv.setEcurrentB(String.valueOf(ebInt));
// else
// qrtmv.setEcurrentB("0");
//
// // 解析并设置C相电流
// int ecInt = ByteUtil.binToInt(new byte[] { data[11], data[10] });
// if (ecInt < 1000)
// qrtmv.setEcurrentC(String.valueOf(ecInt));
// else
// qrtmv.setEcurrentC("0");
//
// qrtmv.setValid(true);
// } else {
// qrtmv.setValid(false);
// }
// return qrtmv;
// }
//
// /**
// * 将查询终端事件记录命令响应消息字节数组解析为消息对象AFN=5DH
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryEventRecordsCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryEventRecordsCommandResponse qprcr = new QueryEventRecordsCommandResponse(Calendar.getInstance(), address);
// Map<String, Integer> ercs = new HashMap<String, Integer>();
//
// int temp = 0;
//
// // 解析并设置数据域
// if (data.length == 64) {
// // int num = 1;
// // erc19-32备用
// for (int j = 0; j < 19; j++) {
// temp = ByteUtil.binToInt(new byte[] { data[j * 2 + 1], data[2 * j] });
// ercs.put("erc" + Integer.toString(j + 1), Integer.valueOf(temp));
// // System.out.println(j+"==="+temp+"==");
// }
//
// qprcr.setErcs(ercs);
// qprcr.setValid(true);
//
// } else {
// qprcr.setValid(false);
// }
// return qprcr;
// }
//
// /**
// * 将查询内存自报数据命令响应消息字节数组解析为消息对象AFH=B2H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryMemeryValueCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryMemeryValueCommandResponse qmvcr = new QueryMemeryValueCommandResponse(Calendar.getInstance(), address);
//
// // 解析并设置数据域
// if (data.length == 8) {
// qmvcr.setValid(true);
// } else {
// qmvcr.setValid(false);
// }
// return qmvcr;
// }
//
// /**
// * 将查询终端固态存储数据命令响应消息字节数组解析为消息对象AFH=B1H
// *
// * @param byteMessage
// * @return
// */
// private AppMessage bytesToQueryHDValueCommandResponse(GBByteFrame gbFrame) {
// byte[] data = gbFrame.FRAME_DATA_BODY; // 获取数据域
// String address = gbFrame.address; // 获取地址域
//
// QueryHDValueCommandResponse qhdvcr = new QueryHDValueCommandResponse(Calendar.getInstance(), address);
// Map<String, String> qhdm = new HashMap<String, String>();
//
// // 解析并设置数据域
// if (data.length > 9) {
// // 解析并设置参数及起止时间数据
// String starttime = ByteUtil.bcdToString(new byte[] { data[4], data[3], data[2], data[1] });
// String endtime = ByteUtil.bcdToString(new byte[] { data[8], data[7], data[6], data[5] });
// if (starttime.equals("") == true || endtime.equals("") == true) {
// qhdvcr.setValid(false);
// return qhdvcr;
// }
//
// Calendar start = Calendar.getInstance();
// Calendar end = Calendar.getInstance();
// start.set(2000 + Integer.parseInt(starttime.substring(0, 2)),
// Integer.parseInt(starttime.substring(2, 4)) - 1,
// Integer.parseInt(starttime.substring(4, 6)),
// Integer.parseInt(starttime.substring(6, 8)), 0, 0);
// end.set(2000 + Integer.parseInt(endtime.substring(0, 2)),
// Integer.parseInt(endtime.substring(2, 4)) - 1,
// Integer.parseInt(endtime.substring(4, 6)),
// Integer.parseInt(endtime.substring(6, 8)), 0, 0);
// long hour = (end.getTimeInMillis() - start.getTimeInMillis()) / (1000 * 3600);
//
// int type = ByteUtil.binToInt(data[0], 7, 4);
// int no = ByteUtil.binToInt(data[0], 3, 0);
// qhdvcr.setType(type);
// qhdvcr.setNo(no);
//
// switch (type) {
// case 0: //雨量参数
// {
// int interval = (data.length - 9) / 3; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 3) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 2], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], NumberFormat.format((Integer.parseInt(realtime) / 10.0), "0.0"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 1: //水位参数
// {
// int interval = (data.length - 9) / 4; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 4) {
// String realtime = ByteUtil.bcdToString(new byte[] {(byte) (data[i + 3] & 0x0F), data[i + 2], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// // 判断正负
// if ((data[i + 3] & 0xf0) == 0xf0)
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / -1000.0, "0.000"));
// else
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 1000.0, "0.000"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 2: //水量参数
// {
// int interval = (data.length - 9) / 5; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 5) {
// String realtime = ByteUtil.bcdToString(new byte[] {(byte) (data[i + 4] & 0x7F), data[i + 3], data[i + 2], data[i + 1], data[i]});
// if (realtime.equals("") == true)
// realtime = "0";
//
// // 判断剩余水量正负符号
// Long realtimelong = Long.valueOf(0);
// if ((data[i + 4] & 0x80) == 0x80)
// realtimelong = Long.valueOf(Long.parseLong(realtime) * -1);
// else
// realtimelong = Long.valueOf(realtime);
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], String.valueOf(realtimelong));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 3: //流速参数
// {
// int interval = (data.length - 9) / 3; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 3) {
// String realtime = ByteUtil.bcdToString(new byte[] {(byte) (data[i + 2] & 0x0F), data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// // 判断正负
// if ((data[i + 2] & 0xf0) == 0xf0)
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / -1000.0, "0.000"));
// else
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 1000.0, "0.000"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 4: //闸位参数
// {
// int interval = (data.length - 9) / 3; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 3) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 2], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 100.0, "0.00"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 5: //功率参数
// {
// int interval = (data.length - 9) / 3; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 3) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 2], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], String.valueOf(Integer.parseInt(realtime)));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 6: //气压参数
// {
// int interval = (data.length - 9) / 3; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 3) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 2], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], String.valueOf(Integer.parseInt(realtime)));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 7: //风速参数
// {
// int interval = (data.length - 9) / 3; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 3) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 2], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 100.0, "0.00"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 8: //水温参数
// {
// int interval = (data.length - 9) / 2; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 2) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 10.0, "0.0"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 10: //土壤含水率参数
// {
// int interval = (data.length - 9) / 2; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 2) {
// String realtime = ByteUtil.bcdToString(new byte[] {data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 10.0, "0.0"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// case 11: //水压参数
// {
// int interval = (data.length - 9) / 4; //有几个返回的数值
// String[] times = new String[interval]; //有几个返回的值就有几个时间，从起始时间开始，不包括结束时间
// int minitue = 0;
// Calendar step = Calendar.getInstance();
// step.setTimeInMillis(start.getTimeInMillis());
// if (interval > 0) {
// minitue = (int) (hour * 60 / interval);
// }
//
// int count = 0;
// for (int i = 9; i < data.length; i = i + 4) {
// String realtime = ByteUtil.bcdToString(new byte[] { data[i + 3], data[i + 2 ], data[i + 1], data[i] });
// if (realtime.equals("") == true)
// realtime = "0";
//
// String timeStr = TimeFormat.format(step.getTime(), "yyyy-MM-dd HH:mm");
// times[count] = timeStr;
//
// qhdm.put(times[count], NumberFormat.format(Integer.parseInt(realtime) / 100.0, "0.00"));
//
// step.add(Calendar.MINUTE, minitue);
// count++;
// }
// qhdvcr.setTimes(times);
// qhdvcr.setResultMap(qhdm);
// break;
// }
// default://其它参数未实现
// qhdvcr.setValid(false);
// return qhdvcr;
// }
//
// qhdvcr.setValid(true);
//
// } else {
// qhdvcr.setValid(false);
// }
// return qhdvcr;
// }
/**
* 将消息对象解析为字节数组
*
* @param SentMessage message
* @return byte[]
*/
public byte[] messageToBytes(AppMessage message) {
byte[] frame = null;
// 握手命令
if (message instanceof LinkCommand) {
frame = LinkCommandToBytes((LinkCommand) message);
}
// 读取甲烷参数内存命令
if (message instanceof ReadCH4ParamCommand) {
frame = ReadCH4ParamCommandToBytes((ReadCH4ParamCommand) message);
}
// // 读内存命令
// if (message instanceof FreeMessageResponse) {
// frame = freeMessageResponseToBytes((FreeMessageResponse) message);
// }
//
// // 写内存命令
// if (message instanceof QueryRealTimeValueCommand) {
// frame = queryRealTimeValueCommandToBytes((QueryRealTimeValueCommand) message);
// }
return frame;
}
/**
* 将握手命令转换为字节数组
*
* @param hmr
* @return
*/
private byte[] LinkCommandToBytes(LinkCommand link) {
FINSByteFrame finsFrame = new FINSByteFrame(link.getMessageProducerId());
return finsFrame.toBytes();
}
/**
* 将读取甲烷参数内存命令转换为字节数组
* @param read
* @return
*/
private byte[] ReadCH4ParamCommandToBytes(ReadCH4ParamCommand read) {
byte[] start = ByteUtil.hexStringToBytes(read.getStartAddress(), 3);
FINSByteFrame finsFrame = new FINSByteFrame(read.getDestinationId(),
read.getMessageProducerId(),
read.getMemoryArea(),
start,
read.getCount());
return finsFrame.toBytes();
}
/**
* 从重叠消息中提取规范消息
*/
@Override
public List<byte[]> extractByteMessage(byte[] byteMessage) {
List<byte[]> bytesList = new ArrayList<byte[]>();
int count = 0;
try {
int i = 0;
while (i < byteMessage.length) {
if (byteMessage[i] == FINSByteFrame.HEADER[0] &&
byteMessage[i + 1] == FINSByteFrame.HEADER[1] &&
byteMessage[i + 2] == FINSByteFrame.HEADER[2] &&
byteMessage[i + 3] == FINSByteFrame.HEADER[3]) {
// 匹配上FINS帧头
int length = ByteUtil.binToInt(new byte[]{byteMessage[i + 4], byteMessage[i + 5], byteMessage[i + 6], byteMessage[i + 7]});
if (i + length + 8 <= byteMessage.length) {
Bytes bytes = new Bytes();
bytes.append(byteMessage[i]).append(byteMessage[i + 1]).append(byteMessage[i + 2]).append(byteMessage[i + 3]); //FINS帧头
bytes.append(byteMessage[i + 4]).append(byteMessage[i + 5]).append(byteMessage[i + 6]).append(byteMessage[i + 7]); //FINS长度
// FINS的数据区
for (int j = 0; j < length; j++) {
bytes.append(byteMessage[i + 8 + j]);
}
i = i + length + 8;
bytesList.add(bytes.toBytes());
count++;
} else {
i++;
}
} else {
i++;
}
}
} catch (Exception e) {
e.printStackTrace();
bytesList.clear();
bytesList.add(byteMessage);
return bytesList;
}
if (count == 0) {
bytesList.add(byteMessage);
}
return bytesList;
}
// /**
// * 将退出登录命令对象转换为字节数组AFN=02H
// *
// * @param hmr
// * @return
// */
// private byte[] logoutCommandToBytes(LogoutCommand lc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, lc.getDestinationId(),
// GBConstants.DATA_AFN_LOGIN, new byte[] { (byte) 0xF1 });
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置地址命令对象转换为字节数组AFN=10H
// *
// * @param message
// * @return
// */
// private byte[] setAddressCommandToBytes(SetAddressCommand sac) {
// String address = sac.getNewAddress();
//
// // 解析设置的新地址内容
// byte[] add1 = ByteUtil.bcdStringToBytes(address.substring(0, 6));
// byte[] add2 = ByteUtil.hexStringToBytes(address.substring(7, 10));
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(add1).append(add2[1]).append(add2[0]);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, sac.getDestinationId(),
// GBConstants.DATA_AFN_SETADDRESS, data.toBytes(), pw,
// sac.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询地址命令对象转换为字节数组AFN=50H
// *
// * @param message
// * @return
// */
// private byte[] queryAddressCommandToBytes(QueryAddressCommand qac) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qac.getDestinationId(),
// GBConstants.DATA_AFN_QUERYADDRESS);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置时钟命令对象转换为字节数组AFN=11H
// *
// * @param scc
// * @return
// */
// private byte[] setClockCommandToBytes(SetClockCommand scc) {
// Calendar clock = scc.getClock();
//
// // 解析设置的新时钟内容
// int week = clock.get(Calendar.DAY_OF_WEEK);
// switch (week) {
// case Calendar.MONDAY:
// case Calendar.TUESDAY:
// case Calendar.WEDNESDAY:
// case Calendar.THURSDAY:
// case Calendar.FRIDAY:
// case Calendar.SATURDAY:
// week = week - 1;
// break;
// case Calendar.SUNDAY:
// week = week - 1 + 7;
// break;
// }
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(ByteUtil.intToBcd(clock.get(Calendar.SECOND))); // 秒
// data.append(ByteUtil.intToBcd(clock.get(Calendar.MINUTE))); // 分
// data.append(ByteUtil.intToBcd(clock.get(Calendar.HOUR_OF_DAY))); // 时
// data.append(ByteUtil.intToBcd(clock.get(Calendar.DAY_OF_MONTH))); // 日
// data.append((byte) (ByteUtil.intToBcd(clock.get(Calendar.MONTH) + 1) | (ByteUtil
// .intToBcd(week) << 5))); // 月
// data.append(ByteUtil.intToBcd(clock.get(Calendar.YEAR) - 2000)); // 年
//
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, scc.getDestinationId(),
// GBConstants.DATA_AFN_SETCLOCK, data.toBytes(), pw,
// scc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询时钟命令对象转换为字节数组AFN=51H
// *
// * @param message
// * @return
// */
// private byte[] queryClockCommandToBytes(QueryClockCommand qcc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qcc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYCLOCK);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置工作模式命令对象转换为字节数组AFN=12H
// *
// * @param message
// * @return
// */
// private byte[] setPatternCommandToBytes(SetPatternCommand spc) {
// String newPattern = spc.getPattern();
// if (newPattern.length() > 2) {
// newPattern = newPattern.substring(0, 2);
// }
//
// // 解析设置的新工作模式内容
// byte[] pattern = ByteUtil.hexStringToBytes(newPattern);
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(pattern);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, spc.getDestinationId(),
// GBConstants.DATA_AFN_SETWORKPATTERN, data.toBytes(), pw,
// spc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询工作模式命令对象转换为字节数组AFN=52H
// *
// * @param message
// * @return
// */
// private byte[] queryPatternCommandToBytes(QueryPatternCommand qpc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qpc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWORKPATTERN);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置自报种类及时间间隔命令对象转换为字节数组AFN=A1H
// *
// * @param message
// * @return
// */
// private byte[] setIntervalCommandToBytes(SetIntervalCommand sic) {
// Map<String, Integer> newIntervals = sic.getIntervals();
//
// // 解析设置的新工作模式内容
// int bin = 0; // 自报种类
// Bytes di = new Bytes(); // 每种参数自报的时间间隔
// for (int i = 0; i < SetIntervalCommand.index.length; i++) {
// String key = SetIntervalCommand.index[i];
// if (newIntervals.containsKey(key)) {
// bin = (int) (bin + Math.pow(2, i));
// int val = ((Integer) newIntervals.get(key)).intValue();
// int low = val % 100;
// int high = val / 100;
// di.append(ByteUtil.intToBcd(low)).append(ByteUtil.intToBcd(high));
// } else {
// di.append(new byte[] { 0x00, 0x00 });
// }
// }
//
// // 设置数据域
// Bytes data = new Bytes();
// byte[] db = ByteUtil.intToBins(bin, 2);
// data.append(db[1]).append(db[0]).append(di.toBytes());
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, sic.getDestinationId(),
// GBConstants.DATA_AFN_SETINTERVAL, data.toBytes(), pw,
// sic.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询自报种类及时间间隔命令对象转换为字节数组AFN=53H
// *
// * @param message
// * @return
// */
// private byte[] queryIntervalCommandToBytes(QueryIntervalCommand qic) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qic.getDestinationId(),
// GBConstants.DATA_AFN_QUERYINTERVAL);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端需查询的实时数据种类命令对象转换为字节数组AFN=A0H
// *
// * @param message
// * @return
// */
// private byte[] setRttypesCommandToBytes(SetRttypesCommand src) {
// Set<String> newRttypes = src.getRttypes();
//
// // 解析设置的新工作模式内容
// int bin = 0; // 自报种类
// for (int i = 0; i < SetRttypesCommand.index.length; i++) {
// String key = SetRttypesCommand.index[i];
// if (newRttypes.contains(key)) {
// bin = (int) (bin + Math.pow(2, i));
// }
// }
//
// // 设置数据域
// Bytes data = new Bytes();
// byte[] db = ByteUtil.intToBins(bin, 2);
// data.append(db[1]).append(db[0]);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, src.getDestinationId(),
// GBConstants.DATA_AFN_SETRTTYPES, data.toBytes(), pw,
// src.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端需查询的实时数据种类命令对象转换为字节数组AFN=54H
// *
// * @param message
// * @return
// */
// private byte[] queryRttypesCommandToBytes(QueryRttypesCommand qrc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qrc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYRTTYPES);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端充值量命令对象转换为字节数组AFN=15H
// *
// * @param message
// * @return
// */
// private byte[] setChargingCommandToBytes(SetChargingCommand scc) {
// String charging = scc.getNewCharging();
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(ByteUtil.intToBcdsHL(Long.parseLong(charging), 4));
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, scc.getDestinationId(),
// GBConstants.DATA_AFN_SETCHARGING, data.toBytes(), pw,
// scc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端充值量命令对象转换为字节数组AFN=55H
// *
// * @param message
// * @return
// */
// private byte[] queryChargingCommandToBytes(QueryChargingCommand qcc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qcc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYCHARGING);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端剩余水量报警值命令对象转换为字节数组AFN=16H
// *
// * @param message
// * @return
// */
// private byte[] setWarningCommandToBytes(SetWarningCommand swc) {
// String warning = swc.getNewWarning();
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(ByteUtil.intToBcdsHL(Long.parseLong(warning), 3));
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, swc.getDestinationId(),
// GBConstants.DATA_AFN_SETWARNING, data.toBytes(), pw,
// swc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端剩余水量报警值命令对象转换为字节数组AFN=56H
// *
// * @param message
// * @return
// */
// private byte[] queryWarningCommandToBytes(QueryWarningCommand qwc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qwc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWARNING);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端水位参数命令对象转换为字节数组AFN=17H
// *
// * @param message
// * @return
// */
// private byte[] setWlParamCommandToBytes(SetWlParamCommand swpc) {
// List<List<Double>> wlParams = swpc.getWlParams();
//
// // 设置数据域
// Bytes data = new Bytes();
// for (int i = 0; i < wlParams.size(); i++) {
// List<Double> wlp = (List<Double>) wlParams.get(i);
//
// int benchmark = (int) (((Double) wlp.get(0)).doubleValue() * 100);
// int upper = (int) (((Double) wlp.get(1)).doubleValue() * 100);
// int lower = (int) (((Double) wlp.get(2)).doubleValue() * 100);
//
// byte[] bb = ByteUtil.intToBcdsHL(Math.abs(benchmark), 3);
// if (benchmark < 0) {
// bb[2] = (byte) (bb[2] + 0x80);
// }
// byte[] ub = ByteUtil.intToBcdsHL(upper, 2);
// byte[] lb = ByteUtil.intToBcdsHL(lower, 2);
// data.append(bb).append(ub).append(lb);
// }
//
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, swpc.getDestinationId(),
// GBConstants.DATA_AFN_SETWATERLEVELPARAM, data.toBytes(), pw,
// swpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端水位参数命令对象转换为字节数组AFN=57H
// *
// * @param message
// * @return
// */
// private byte[] queryWlParamCommandToBytes(QueryWlParamCommand qwpc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qwpc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWATERLEVELPARAM);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端水压参数命令对象转换为字节数组AFN=18H
// *
// * @param message
// * @return
// */
// private byte[] setWpParamCommandToBytes(SetWpParamCommand swpc) {
// List<List<Double>> wpParams = swpc.getWpParams();
//
// // 设置数据域
// Bytes data = new Bytes();
// for (int i = 0; i < wpParams.size(); i++) {
// List<Double> wpp = (List<Double>) wpParams.get(i);
//
// int upper = (int) (((Double) wpp.get(0)).doubleValue() * 100);
// int lower = (int) (((Double) wpp.get(1)).doubleValue() * 100);
//
// byte[] ub = ByteUtil.intToBcdsHL(upper, 4);
// byte[] lb = ByteUtil.intToBcdsHL(lower, 4);
// data.append(ub).append(lb);
// }
//
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, swpc.getDestinationId(),
// GBConstants.DATA_AFN_SETWATERPRESSUREPARAM, data.toBytes(), pw,
// swpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端水压参数命令对象转换为字节数组AFN=58H
// *
// * @param message
// * @return
// */
// private byte[] queryWpParamCommandToBytes(QueryWpParamCommand qwpc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qwpc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWATERPRESSUREPARAM);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端水质参数上限命令对象转换为字节数组AFN=19H
// *
// * @param message
// * @return
// */
// private byte[] setWqUpperParamCommandToBytes(SetWqUpperParamCommand swpc) {
// Map<String, String> newWqParams = swpc.getWqParams();
//
// // 解析设置的新水质参数内容
// int indexBin = 0; // 参数种类
// Bytes di = new Bytes();
// for (int i = 0; i < SetWqUpperParamCommand.index.length; i++) {
// String key = SetWqUpperParamCommand.index[i];
// if (newWqParams.containsKey(key)) {
// indexBin = (int) (indexBin + Math.pow(2, i));
// String valStr = (String) newWqParams.get(key);
// String[] format = Configure.getProperty("F" + SetWqUpperParamCommand.index[i], "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
//
// int val = 0;
// String pattern = "0";
// try {
// if (dd == 0) {
// val = NumberFormat.parseInt(valStr, pattern);
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// val = (int) (NumberFormat.parseDouble(valStr, pattern) * Math.pow(10, dd));
// }
// } catch (Exception e) {
// e.printStackTrace();
// }
// String valIntStr = NumberFormat.format(val, "0"); // 转换后的整数
// if (dt <= 8) {
// byte[] vb = ByteUtil.bcdStringToBytes(valIntStr, 4);
// di.append(vb[3]).append(vb[2]).append(vb[1]).append(vb[0]);
// } else {
// byte[] vb = ByteUtil.bcdStringToBytes(valIntStr, 5);
// di.append(vb[4]).append(vb[3]).append(vb[2]).append(vb[1]).append(vb[0]);
// }
// }
// }
//
// // 设置数据域
// Bytes data = new Bytes();
// byte[] db = ByteUtil.intToBins(indexBin, 5);
// data.append(db[4]).append(db[3]).append(db[2]).append(db[1]).append(db[0]);
// data.append(di.toBytes());
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, swpc.getDestinationId(),
// GBConstants.DATA_AFN_SETWATERQUALITYUPPERPARAM,
// data.toBytes(), pw, swpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端水质参数下限命令对象转换为字节数组AFN=1AH
// *
// * @param message
// * @return
// */
// private byte[] setWqLowerParamCommandToBytes(SetWqLowerParamCommand swpc) {
// Map<String, String> newWqParams = swpc.getWqParams();
//
// // 解析设置的新水质参数内容
// int indexBin = 0; // 参数种类
// Bytes di = new Bytes();
// for (int i = 0; i < SetWqLowerParamCommand.index.length; i++) {
// String key = SetWqLowerParamCommand.index[i];
// if (newWqParams.containsKey(key)) {
// indexBin = (int) (indexBin + Math.pow(2, i));
// String valStr = (String) newWqParams.get(key);
// String[] format = Configure.getProperty("F" + SetWqLowerParamCommand.index[i], "").split(",");
// int dt = Integer.parseInt(format[0]); // 数据的总位数
// int dd = Integer.parseInt(format[1]); // 数据的小数位
//
// int val = 0;
// String pattern = "0";
// try {
// if (dd == 0) {
// val = NumberFormat.parseInt(valStr, pattern);
// } else {
// pattern = "0.";
// for (int z = 0; z < dd; z++) {
// pattern = pattern + "0";
// }
// val = (int) (NumberFormat.parseDouble(valStr, pattern) * Math.pow(10, dd));
// }
// } catch (Exception e) {
// e.printStackTrace();
// }
// String valIntStr = NumberFormat.format(val, "0"); // 转换后的整数
// if (dt <= 8) {
// byte[] vb = ByteUtil.bcdStringToBytes(valIntStr, 4);
// di.append(vb[3]).append(vb[2]).append(vb[1]).append(vb[0]);
// } else {
// byte[] vb = ByteUtil.bcdStringToBytes(valIntStr, 5);
// di.append(vb[4]).append(vb[3]).append(vb[2]).append(vb[1]).append(vb[0]);
// }
// }
// }
//
// // 设置数据域
// Bytes data = new Bytes();
// byte[] db = ByteUtil.intToBins(indexBin, 5);
// data.append(db[4]).append(db[3]).append(db[2]).append(db[1]).append(db[0]);
// data.append(di.toBytes());
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, swpc.getDestinationId(),
// GBConstants.DATA_AFN_SETWATERQUALITYLOWERPARAM,
// data.toBytes(), pw, swpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端水质参数上限命令对象转换为字节数组AFN=59H
// *
// * @param message
// * @return
// */
// private byte[] queryWqUpperParamCommandToBytes(QueryWqUpperParamCommand qwpc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qwpc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWATERQUALITYUPPERPARAM);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端水质参数下限命令对象转换为字节数组AFN=5AH
// *
// * @param message
// * @return
// */
// private byte[] queryWqLowerParamCommandToBytes(QueryWqLowerParamCommand qwpc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qwpc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWATERQUALITYLOWERPARAM);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端流量参数命令对象转换为字节数组AFN=1FH
// *
// * @param message
// * @return
// */
// private byte[] setWfParamCommandToBytes(SetWfParamCommand swpc) {
// List<Double> newUppers = swpc.getNewUppers();
//
// // 设置数据域
// Bytes data = new Bytes();
// for (int i = 0; i < newUppers.size(); i++) {
// double value = ((Double) newUppers.get(i)).doubleValue();
// int upper = (int) (Math.abs(value) * 1000);
// byte[] ub = ByteUtil.intToBcdsHL(upper, 5);
// if (value < 0) {
// ub[4] = (byte) (ub[4] + 0xF0);
// }
// data.append(ub);
// }
//
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, swpc.getDestinationId(),
// GBConstants.DATA_AFN_SETWATERFLOWUPPERPARAM, data.toBytes(),
// pw, swpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端流量参数命令对象转换为字节数组AFN=64H
// *
// * @param message
// * @return
// */
// private byte[] queryWfParamCommandToBytes(QueryWfParamCommand qwpc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qwpc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYWATERFLOWUPPERPARAM);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端实时值命令对象转换为字节数组AFN=B0H
// *
// * @param message
// * @return
// */
// private byte[] queryRealTimeValueCommandToBytes(QueryRealTimeValueCommand qrtvc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// qrtvc.getRttype(), qrtvc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYREALTIMEVALUE);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端水量表底值命令对象转换为字节数组AFN=1BH
// *
// * @param message
// * @return
// */
// private byte[] setFlowInitCommandToBytes(SetFlowInitCommand sfic) {
// List<Long> inits = sfic.getNewInits();
//
// // 设置数据域
// Bytes data = new Bytes();
// for (int i = 0; i < inits.size(); i++) {
// long init = ((Long) inits.get(i)).longValue();
// byte[] ib = ByteUtil.intToBcdsHL(init, 5);
// data.append(ib);
// }
//
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, sfic.getDestinationId(),
// GBConstants.DATA_AFN_SETFLOWINIT, data.toBytes(), pw,
// sfic.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端启报阈值及存储时间段间隔命令对象转换为字节数组AFN=20H
// *
// * @param message
// * @return
// */
// private byte[] setThresholdCommandToBytes(SetThresholdCommand stc) {
// int type = stc.getType();
// int no = stc.getNo();
// int inter = stc.getInter();
// double thresh = stc.getThresh();
//
// String noHex = ByteUtil.binToHexString(ByteUtil.intToBins(no, 1));
// noHex = noHex.substring(noHex.length() - 1);
// String typeHex = ByteUtil.binToHexString(ByteUtil.intToBins(type, 1));
// typeHex = typeHex.substring(typeHex.length() - 1);
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(ByteUtil.hexStringToBytes(typeHex + noHex));
// data.append(ByteUtil.intToBins(inter, 1));
// byte[] threshBytes = null;
//
// // 控制域FN
// int control_fn = 0;
//
// // 判断设置检测参数的类型
// switch (type) {
// case 0: //雨量参数
// data.append(ByteUtil.intToBcd((int) (thresh * 10)));
// control_fn = 1;
// break;
//
// case 1: //水位参数
// threshBytes = ByteUtil.intToBcdsHL((long) (Math.abs(thresh) * 1000), 4);
// if (thresh < 0) {
// threshBytes[3] = (byte) (threshBytes[3] | 0xF0);
// }
// data.append(threshBytes);
//
// control_fn = 2;
// break;
//
// case 2: //水量参数
// threshBytes = ByteUtil.intToBcdsHL((long) (Math.abs(thresh)), 5);
// if (thresh < 0) {
// threshBytes[4] = (byte) (threshBytes[4] | 0x80);
// }
// data.append(threshBytes);
//
// control_fn = 3;
// break;
//
// case 3: //流速参数
// threshBytes = ByteUtil.intToBcdsHL((long) (Math.abs(thresh) * 1000), 3);
// if (thresh < 0) {
// threshBytes[2] = (byte) (threshBytes[2] | 0xF0);
// }
// data.append(threshBytes);
//
// control_fn = 4;
// break;
//
// case 4: //闸位参数
// threshBytes = ByteUtil.intToBcdsHL((long) (thresh * 100), 3);
// data.append(threshBytes);
//
// control_fn = 5;
// break;
//
// case 5: //功率参数
// threshBytes = ByteUtil.intToBcdsHL((long) thresh, 3);
// data.append(threshBytes);
//
// control_fn = 6;
// break;
//
// case 6: //气压参数
// threshBytes = ByteUtil.intToBcdsHL((long) thresh, 3);
// data.append(threshBytes);
//
// control_fn = 7;
// break;
//
// case 7: //风速参数
// threshBytes = ByteUtil.intToBcdsHL((long) (thresh * 100), 3);
// data.append(threshBytes);
//
// control_fn = 8;
// break;
//
// case 8: //水温参数
// threshBytes = ByteUtil.intToBcdsHL((long) (thresh * 10), 2);
// data.append(threshBytes);
//
// control_fn = 9;
// break;
//
// case 10: //土壤含水率参数
// threshBytes = ByteUtil.intToBcdsHL((long) (thresh * 10), 2);
// data.append(threshBytes);
//
// control_fn = 11;
// break;
//
// case 11: //蒸发量参数
// threshBytes = ByteUtil.intToBcdsHL((long) (thresh * 10), 3);
// data.append(threshBytes);
//
// control_fn = 12;
// break;
//
// case 12: //水压参数
// threshBytes = ByteUtil.intToBcdsHL((long) (thresh * 10), 4);
// data.append(threshBytes);
//
// control_fn = 15;
// break;
//
// default:
// thresh = 0.0;
// }
//
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// control_fn, stc.getDestinationId(),
// GBConstants.DATA_AFN_SETTHRESHOLD, data.toBytes(), pw,
// stc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将设置终端定值量命令对象转换为字节数组AFN=34H
// *
// * @param message
// * @return
// */
// private byte[] setFixedValueCommandToBytes(SetFixedValueCommand sfvc) {
// long fixedvalue = sfvc.getNewFixedValue();
//
// // 设置数据域
// Bytes data = new Bytes();
// byte[] fb = ByteUtil.intToBcdsHL(fixedvalue, 5);
// data.append(fb);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, sfvc.getDestinationId(),
// GBConstants.DATA_AFN_SETFIXEDVALUE, data.toBytes(), pw,
// sfvc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将修改终端密码命令对象转换为字节数组AFN=96H
// *
// * @param message
// * @return
// */
// private byte[] setPasswordCommandToBytes(SetPasswordCommand spc) {
// // 设置数据域
// Bytes data = new Bytes();
// byte[] pb = ByteUtil.intToBcdsHL(spc.getNewPassword(), 2);
// data.append(pb);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// // 构建帧
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, spc.getDestinationId(),
// GBConstants.DATA_AFN_SETPASSWORD, data.toBytes(), pw,
// spc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端实时状态命令对象转换为字节数组AFN=5EH
// *
// * @param message
// * @return
// */
// private byte[] queryRealTimeStatusCommandToBytes(QueryRealTimeStatusCommand qrtsc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_QSS, qrtsc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYREALTIMESTATUS);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将自报响应消息转换为字节数组 自报消息通用响应
// *
// * @param message
// * @return
// */
// private byte[] freeMessageResponseToBytes(FreeMessageResponse fmr) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, fmr.getFcb(),
// fmr.getType(), fmr.getDestinationId(),
// fmr.getAfn(), new byte[] { 0x00 });
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将置终端IC卡功能有效命令转换为字节数组AFN=30H
// *
// * @param message
// * @return
// */
// private byte[] enableICCardCommandToBytes(EnableICCardCommand eiccc) {
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, eiccc.getDestinationId(),
// GBConstants.DATA_AFN_ENABLEICCARD, pw, eiccc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将置终端IC卡功能无效命令转换为字节数组AFN=31H
// *
// * @param message
// * @return
// */
// private byte[] disableICCardCommandToBytes(DisableICCardCommand diccc) {
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, diccc.getDestinationId(),
// GBConstants.DATA_AFN_DISABLEICCARD, pw, diccc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将置终端定值控制投入功能命令转换为字节数组AFN=32H
// *
// * @param message
// * @return
// */
// private byte[] enableFixedValCommandToBytes(EnableFixedValCommand eiccc) {
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, eiccc.getDestinationId(),
// GBConstants.DATA_AFN_ENABLEFIXEDVAL, pw, eiccc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将置终端定值控制退出功能命令转换为字节数组AFN=33H
// *
// * @param message
// * @return
// */
// private byte[] disableFixedValCommandToBytes(DisableFixedValCommand diccc) {
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, diccc.getDestinationId(),
// GBConstants.DATA_AFN_DISABLEFIXEDVAL, pw, diccc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将遥控开启水泵/闸门命令转换为字节数组AFN=92H
// *
// * @param message
// * @return
// */
// private byte[] remoteOpenPumpCommandToBytes(RemoteOpenPumpCommand ropc) {
// byte[] data = ByteUtil.hexStringToBytes(ropc.getPump() + ropc.getNo(), 1);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, ropc.getDestinationId(),
// GBConstants.DATA_AFN_REMOTEOPENPUMP, data, pw, ropc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将遥控关闭水泵/闸门命令转换为字节数组AFN=93H
// *
// * @param message
// * @return
// */
// private byte[] remoteClosePumpCommandToBytes(RemoteClosePumpCommand rcpc) {
// byte[] data = ByteUtil.hexStringToBytes(rcpc.getPump() + rcpc.getNo(), 1);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, rcpc.getDestinationId(),
// GBConstants.DATA_AFN_REMOTECLOSEPUMP, data, pw, rcpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将复位终端参数命令转换为字节数组AFN=90H
// *
// * @param message
// * @return
// */
// private byte[] resetParamCommandToBytes(ResetParamCommand rpc) {
// byte[] data = ByteUtil.hexStringToBytes(rpc.getReset(), 1);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, rpc.getDestinationId(),
// GBConstants.DATA_AFN_RESETPARAM, data, pw, rpc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将清空历史数据单元命令转换为字节数组AFN=90H
// *
// * @param message
// * @return
// */
// private byte[] clearHistoryCommandToBytes(ClearHistoryCommand chc) {
// byte[] data = ByteUtil.hexStringToBytes(chc.getClear(), 1);
// byte[] pw = new byte[] { 0x00, 0x00 };
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, chc.getDestinationId(),
// GBConstants.DATA_AFN_CLEARHISTORY, data, pw, chc.getTime(), 10);
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询水泵电机实时工作数据的命令转换为字节数组AFN=5FH
// *
// * @param message
// * @return
// */
// private byte[] queryQueryRealTimeMotoValueCommandToBytes(
// QueryRealTimeMotoValueCommand qrtmv) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qrtmv.getDestinationId(),
// GBConstants.DATA_AFN_QUERYEMOTOSS);
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询终端事件记录的命令转换为字节数组5DH
// *
// * @param message
// * @return
// */
// private byte[] queryEventRecordsCommandToBytes(QueryEventRecordsCommand qerc) {
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qerc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYEVENTREC);
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询内存自报数据的命令转换为字节数组B2H
// *
// * @param message
// * @return
// */
// private byte[] queryQueryMemeryValueCommandToBytes(QueryMemeryValueCommand qerc) {
// Calendar bclock = qerc.getBdate();
// Calendar eclock = qerc.getEdate();
//
// // 设置数据域
// Bytes data = new Bytes();
//
// data.append(ByteUtil.intToBcd(bclock.get(Calendar.MINUTE))); // 分
// data.append(ByteUtil.intToBcd(bclock.get(Calendar.HOUR_OF_DAY))); // 时
// data.append(ByteUtil.intToBcd(bclock.get(Calendar.DAY_OF_MONTH))); // 日
// data.append(ByteUtil.intToBcd(bclock.get(Calendar.MONTH) + 1)); // 月
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.MINUTE))); // 分
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.HOUR_OF_DAY))); // 时
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.DAY_OF_MONTH))); // 日
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.MONTH) + 1)); // 月
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// GBConstants.CTRL_DIR0_COMM, qerc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYMEMERYVALUE, data.toBytes());
//
// return gbFrame.toBytes();
// }
//
// /**
// * 将查询固态存储数据的命令转换为字节数组B1H
// *
// * @param message
// * @return
// */
// private byte[] queryQueryHDValueCommandToBytes(QueryHDValueCommand qhdc) {
// int type = qhdc.getType();
// int no = qhdc.getNo();
// Calendar sclock = qhdc.getSclock();
// Calendar eclock = qhdc.getEclock();
//
// int i = type * 16 + no;
//
// int control_fn = GBConstants.CTRL_DIR0_QACC;
// if (type == 0) //查询雨量参数
// control_fn = GBConstants.CTRL_DIR0_QRF;
// else if (type == 1) //查询水位参数
// control_fn = GBConstants.CTRL_DIR0_QWL;
// else if (type == 2) //查询水量参数
// control_fn = GBConstants.CTRL_DIR0_QACC;
// else if (type == 3) //查询流速参数
// control_fn = GBConstants.CTRL_DIR0_QACC;
// else if (type == 4) //查询闸位参数
// control_fn = GBConstants.CTRL_DIR0_QBC;
// else if (type == 5) //查询功率参数
// control_fn = GBConstants.CTRL_DIR0_QPW;
// else if (type == 6) //查询气压参数
// control_fn = GBConstants.CTRL_DIR0_QAP;
// else if (type == 7) //查询风速参数
// control_fn = GBConstants.CTRL_DIR0_QWS;
// else if (type == 8) //查询水温参数
// control_fn = GBConstants.CTRL_DIR0_QWT;
// else if (type == 9) //查询水质参数
// control_fn = GBConstants.CTRL_DIR0_QWQ;
// else if (type == 10) //查询土壤含水率参数
// control_fn = GBConstants.CTRL_DIR0_QSA;
// else if (type == 11) //查询水压参数
// control_fn = GBConstants.CTRL_DIR0_QHP;
//
// // 设置数据域
// Bytes data = new Bytes();
// data.append(ByteUtil.intToBins(i, 1));
//
// data.append(ByteUtil.intToBcd(sclock.get(Calendar.HOUR_OF_DAY))); // 时
// data.append(ByteUtil.intToBcd(sclock.get(Calendar.DAY_OF_MONTH))); // 日
// data.append(ByteUtil.intToBcd(sclock.get(Calendar.MONTH) + 1)); // 月
// data.append(ByteUtil.intToBcd(sclock.get(Calendar.YEAR))); // 年
//
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.HOUR_OF_DAY))); // 时
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.DAY_OF_MONTH))); // 日
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.MONTH) + 1)); // 月
// data.append(ByteUtil.intToBcd(eclock.get(Calendar.YEAR))); // 年
//
// GBByteFrame gbFrame = new GBByteFrame(GBConstants.CTRL_DIR_DOWN,
// GBConstants.CTRL_DIV_FALSE, GBConstants.CTRL_MAX_FCB,
// control_fn, qhdc.getDestinationId(),
// GBConstants.DATA_AFN_QUERYHARDDISCVALUE, data.toBytes());
//
// return gbFrame.toBytes();
// }
//
//
// /**
// * 从重叠消息中提取规范消息
// */
// public List<byte[]> extractByteMessage(byte[] byteMessage) {
// List<byte[]> bytesList = new ArrayList<byte[]>();
//
// try {
// int i = 0;
// while (i < byteMessage.length) {
// if ((byteMessage[i] == GBByteFrame.FRAME_HEAD) && (byteMessage[i + 2] == GBByteFrame.FRAME_HEAD)) {
// int length = ByteUtil.binToInt(new byte[]{byteMessage[i + 1]});
// if (i + length + 5 <= byteMessage.length && byteMessage[i + length + 4] == GBByteFrame.FRAME_END) {
// Bytes bytes = new Bytes();
// bytes.append(byteMessage[i]).append(byteMessage[i + 1]).append(byteMessage[i + 2]);
// for (int j = 0; j < length + 2; j++) {
// bytes.append(byteMessage[i + 3 + j]);
// }
//
// i = i + length + 5;
// bytesList.add(bytes.toBytes());
// } else {
// i++;
// }
// } else {
// i++;
// }
// }
// } catch (Exception e) {
// bytesList.clear();
// bytesList.add(byteMessage);
// return bytesList;
// }
//
// return bytesList;
// }
}
