发送包数据的代码
//发送的controller层
package com.rengu.project.integrationoperations.controller;
import com.rengu.project.integrationoperations.configuration.LogConfig;
//import com.rengu.project.integrationoperations.configuration.LogConfig;
import com.rengu.project.integrationoperations.entity.*;
import com.rengu.project.integrationoperations.enums.SystemStatusCodeEnum;
import com.rengu.project.integrationoperations.service.WebSendToCService;
import com.rengu.project.integrationoperations.service.SysErrorLogService;
import com.rengu.project.integrationoperations.service.WebReceiveToCService;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.validation.constraints.NotNull;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* web端发送到c++端
*
* @Author:
* @Date: 2019/4/12 13:30
*/
@RestController
@RequestMapping(path = "/deployment")
@Slf4j
public class WebSendToCController {
private final WebSendToCService webSendToCService;
private final WebReceiveToCService receiveInformationService;
private final SysErrorLogService sysErrorLogService;
// 设置同批数据为同一序号
private final int serialNumber = 0;
@Autowired
public WebSendToCController(WebSendToCService webSendToCService, WebReceiveToCService receiveInformationService,
SysErrorLogService sysErrorLogService) {
this.webSendToCService = webSendToCService;
this.receiveInformationService = receiveInformationService;
this.sysErrorLogService = sysErrorLogService;
}
// 发送系统校时
@PostMapping("/sendSystemTiming/communication")
//@LogConfig("发送系统校时")
public ResultEntity sendSystemTiming(SystemSendTimingCMD systemSendTimingCMD,
@NonNull String host, @NonNull String updateAll) throws IOException {
try {
webSendToCService.sendSystemTiming(systemSendTimingCMD, host, updateAll, serialNumber);
} catch (Exception e) {
// receiveInformationService.receiveSocketHandler1(byteBuffer, host);
System.out.println("发送系统校时异常");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(host);
sysErrorLogEntity.setErrorMsg("发送系统校时异常");
sysErrorLogEntity.setErrorType("系统校时异常");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, null);
}
// 添加定时发送
// @PostMapping("/addSystemTimingTask/communication")
// //@LogConfig("添加定时发送")
// public ResultEntity addSystemTimingTask(String timeNow, String timingPattern, String time, String sendTime,
// String host, String updateAll) throws SchedulerException {
// return new ResultEntity(SystemStatusCodeEnum.SUCCESS, webSendToCService.addTimeSendTask(timeNow, time, sendTime,
// timingPattern, host, updateAll, serialNumber));
// }
// 设备复位
@PostMapping("/sendDeviceRestoration/communication")
public ResultEntity sendDeviceRestoration(DeviceRestorationSendCMD deviceRestorationSendCMD, String host,
@NonNull String updateAll) {
try {
webSendToCService.sendDeviceRestoration(deviceRestorationSendCMD, host, updateAll, serialNumber);
} catch (Exception e) {
System.out.println("设备复位异常");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(host);
sysErrorLogEntity.setErrorMsg("发送设备复位异常");
sysErrorLogEntity.setErrorType("设备复位异常");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
}
// 设备自检指令
@PostMapping("/sendDeviceCheckCMD/communication")
//@LogConfig("设备自检指令")
public ResultEntity sendDeviceCheckCMD(DeviceCheckCMD deviceCheckCMD, String host, @NonNull String updateAll) {
try {
webSendToCService.sendDeviceCheckCMD(deviceCheckCMD, host, updateAll, serialNumber);
} catch (Exception e) {
e.printStackTrace();
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(host);
sysErrorLogEntity.setErrorMsg("发送设备自检指令异常");
sysErrorLogEntity.setErrorType("设备自检指令异常");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
}
// 软件版本更新
@PostMapping("/sendSoftwareUpdateCMD/communication")
//@LogConfig("软件版本更新")
public ResultEntity sendSoftwareUpdateCMD(String timeNow, String cmd, String softwareID, String host,
@NonNull String updateAll) {
try {
webSendToCService.sendSoftwareUpdateCMD(timeNow, cmd, softwareID.trim(), host, updateAll, serialNumber);
} catch (Exception e) {
System.out.println("软件版本更新异常");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(host);
sysErrorLogEntity.setErrorMsg("发送软件版本更新异常");
sysErrorLogEntity.setErrorType("软件版本更新异常");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
}
// 设备网络参数更新指令
@PostMapping("/sendDeviceNetworkCMD/communication")
//@LogConfig("设备网络参数更新指令")
public ResultEntity sendDeviceNetworkCMD(SendDeviceNetWorkParam sendDeviceNetWorkParam, String host,
@NonNull String updateAll) {
try {
webSendToCService.sendDeviceNetworkCMD(sendDeviceNetWorkParam, host, updateAll, serialNumber);
} catch (Exception e) {
// log.info("设备网络参数更新指令异常", e);
System.out.println("设备网络参数更新指令异常");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(host);
sysErrorLogEntity.setErrorMsg("发送设备网络参数更新指令异常");
sysErrorLogEntity.setErrorType("设备网络参数更新指令异常");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送指令成功");
}
// 设备工作流程控制指令
@PostMapping("/sendDeviceWorkFlowCMD/communication")
//@LogConfig("设备工作流程控制指令")
public ResultEntity sendDeviceWorkFlowCMD(DeviceWorkFlowCMD deviceWorkFlowCMD, SystemControlCMD systemControlCMD,
Integer count, String host, @NonNull String updateAll) {
try {
webSendToCService.sendDeviceWorkFlowCMD(deviceWorkFlowCMD, systemControlCMD, count, host, updateAll,
serialNumber);
} catch (Exception e) {
// log.info("设备工作流程控制指令异常", e);
System.out.println("设备工作流程控制指令异常");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(host);
sysErrorLogEntity.setErrorMsg("发送设备工作流程控制指令");
sysErrorLogEntity.setErrorType("设备工作流程控制指令");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送控制指令成功");
}
// 设备工作流程控制指令(雷达分机指令)(单发,群发)
@PostMapping("/sendExtensionInstructionsCMD/communication")
//@LogConfig("设备工作流程控制指令(雷达分机指令)")
public ResultEntity sendExtensionInstructions(@RequestBody ArrayList<RadarDeviceCMD> deviceWorkFlowCMD,
@RequestHeader String deviceHost, @RequestHeader String updateAll) {
if (512 - deviceWorkFlowCMD.size() * 32 < 0) {
return new ResultEntity(SystemStatusCodeEnum.ERROR, "指令条数已超出");
} else {
try {
webSendToCService.sendExtensionInstructionsCMD(deviceWorkFlowCMD, deviceHost, updateAll, serialNumber);
} catch (Exception e) {
// e.printStackTrace();
System.out.println("设备工作流程控制指令(雷达分机指令)");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(deviceHost);
sysErrorLogEntity.setErrorMsg("发送设备工作流程控制指令(雷达分机指令)");
sysErrorLogEntity.setErrorType("设备工作流程控制指令(雷达分机指令)");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送雷达分机指令成功");
}
}
// 设备工作流程控制指令(雷达系统指令)(单发,群发)
@PostMapping("/sendSystemInstructionsCMD/communication")
//@LogConfig("设备工作流程控制指令(雷达系统指令)")
public ResultEntity sendSystemInstructions(@RequestBody ArrayList<SystemControlCMD> systemControlCMDs,
@RequestHeader String deviceHost, @RequestHeader String updateAll) {
if (512 - systemControlCMDs.size() * 48 < 0) {
return new ResultEntity(SystemStatusCodeEnum.ERROR, "指令条数已超出");
} else {
try {
webSendToCService.sendSystemInstructionsCMD(systemControlCMDs, deviceHost, updateAll, serialNumber);
} catch (Exception e) {
System.out.println("设备工作流程控制指令(雷达系统指令)");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(deviceHost);
sysErrorLogEntity.setErrorMsg("发送设备工作流程控制指令(雷达系统指令)");
sysErrorLogEntity.setErrorType("设备工作流程控制指令(雷达系统指令)");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送雷达系统指令成功");
}
}
// 敌我系统控制(单发,群发)
@PostMapping("/sendEnemyAndUsSystemCMD/communication")
//@LogConfig("敌我系统控制")
public ResultEntity sendEnemyAndUsCMD(@RequestHeader String deviceHost, @RequestHeader String updateAll,
@RequestBody ArrayList<EnemyAndUsCMD> enemyAndUsCMDs) throws IOException {
if (512 - enemyAndUsCMDs.size() * 64 < 0) {
return new ResultEntity(SystemStatusCodeEnum.ERROR, "指令条数已超出");
} else {
try {
webSendToCService.sendEnemyAndUsCMD(enemyAndUsCMDs, deviceHost, updateAll, serialNumber);
} catch (Exception e) {
System.out.println("敌我系统控制");
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setHost(deviceHost);
sysErrorLogEntity.setErrorMsg("发送敌我系统控制");
sysErrorLogEntity.setErrorType("敌我系统控制");
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogService.saveError(sysErrorLogEntity);
}
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, "发送敌我系统指令成功");
}
}
// 查询所有
@GetMapping
public ResultEntity findAll() {
return new ResultEntity(SystemStatusCodeEnum.SUCCESS, receiveInformationService.findAll());
}
}
//发送的service层
package com.rengu.project.integrationoperations.service;
import com.rengu.project.integrationoperations.entity.*;
import com.rengu.project.integrationoperations.enums.SystemStatusCodeEnum;
import com.rengu.project.integrationoperations.exception.SystemException;
import com.rengu.project.integrationoperations.repository.CMDSerialNumberRepository;
import com.rengu.project.integrationoperations.repository.HostRepository;
import com.rengu.project.integrationoperations.repository.TimingTaskRepository;
import com.rengu.project.integrationoperations.thread.TCPThread;
import com.rengu.project.integrationoperations.util.JsonUtils;
import com.rengu.project.integrationoperations.util.SocketConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.*;
import static com.rengu.project.integrationoperations.util.SocketConfig.BinaryToDecimal;
/**
* java端发送给c++端
*
* @Author: yaojiahao
* @Date: 2019/4/12 13:32
*/
@Service
@Slf4j
public class WebSendToCService {
private byte backups = 0;
private final CMDSerialNumberRepository cmdSerialNumberRepository;
private short shorts = 0;
private final HostRepository hostRepository;// 当前连接的最大数·
private final TimingTaskRepository timingTaskRepository;
private final SchedulerFactoryBean schedulerFactoryBean;
private SimpMessagingTemplate simpMessagingTemplate;
DynamicJobService jobService;
@Autowired
private SysLogService sysLogService;
public WebSendToCService(CMDSerialNumberRepository cmdSerialNumberRepository,
SchedulerFactoryBean schedulerFactoryBean, TimingTaskRepository timingTaskRepository,
HostRepository hostRepository) { //
this.cmdSerialNumberRepository = cmdSerialNumberRepository;
this.hostRepository = hostRepository;
this.timingTaskRepository = timingTaskRepository;
// this.jobService = jobService;
this.schedulerFactoryBean = schedulerFactoryBean;
}
// 系统控制指令帧格式说明（头部固定信息）
private void sendSystemControlCmdFormat(ByteBuffer byteBuffer, int dataLength, short purPoseAddress,
short sourceAddress, byte regionID, byte themeID, short messageCategory, long sendingDateTime,
int seriesNumber, int packageSum, int currentNum, int dataLengthSum, short version, int retain1,
short retain2) {
// 十六进制转换成十进制
byteBuffer.putInt(2122389735); // 报文头 7E8118E7
byteBuffer.putInt(dataLength); // 当前包数据长度
// 获取当前pid (无法获取目标的pid，暂时拿源地址的PID)
// String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
byteBuffer.putShort(shorts); // 目的地址(设备ID号)
byteBuffer.putShort(sourceAddress); // 源地址(设备ID号)
byteBuffer.put(regionID); // 域ID(预留)
byteBuffer.put(themeID); // 主题ID(预留)
byteBuffer.putShort(messageCategory); // 信息类别号 (各种交换的信息格式报分配唯一的编号)
// byteBuffer.putLong(getTimes()); // 发报日期时间
byteBuffer.putLong((long) 0);
byteBuffer.putInt(seriesNumber); // 序列号 (同批数据的序列号相同，不同批数据的序列号不同)
byteBuffer.putInt(1); // 包总数 (当前发送的数据，总共分成几个包发送。默认一包)
byteBuffer.putInt(currentNum); // 当前包号 (当前发送的数据包序号。从1开始，当序列号不同时，当前包号清零，从1开始。)
byteBuffer.putInt(1536); // 数据总长度
// 高八位 主版本号 低八位 副版本号 0001 1000
byteBuffer.putShort((short) 24); // 版本号
byteBuffer.putInt(retain1); // 保留字段
byteBuffer.putShort(retain2); // 保留字段
}
/**
* 3.4.6.3 设备自检指令
*
* @throws IOException
*/
public void sendDeviceCheckCMD(DeviceCheckCMD deviceCheckCMD, String host, String updateAll, int serialNumber)
throws IOException {
// 群发消息
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
// 调用序号自增
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendDeviceCheckCMD(deviceCheckCMD, allHost.getHost(), "0", serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(84);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 84, backups, backups, backups, backups, (short) 12290, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
byteBuffer.putInt(0); // 信息长度 待定
byteBuffer.putLong(Long.parseLong(deviceCheckCMD.getTaskFlowNo()));// 任务流水号
byteBuffer.put(Byte.parseByte(deviceCheckCMD.getCheckType())); // 自检类型
byteBuffer.putShort(Short.parseShort(deviceCheckCMD.getCheckPeriod())); // 自检周期
byte num = (byte) (Integer.parseInt(deviceCheckCMD.getCheckNum()));
byteBuffer.put(num); // 自检数量
byteBuffer.putInt(Integer.parseInt(deviceCheckCMD.getSingleMachineCode())); // 自检单机代码
// 雷达
byteBuffer.putShort(Short.parseShort(deviceCheckCMD.getRadarSelfChecking())); // 自检频率
byteBuffer.put(Byte.parseByte(deviceCheckCMD.getRadarBranChoose()));// 带宽选择
byteBuffer.put(Byte.parseByte(deviceCheckCMD.getRadarSelfChoose()));// 自检模式选择
// 敌我
byteBuffer.putShort(Short.parseShort(deviceCheckCMD.getEnemyAndUsSelfChecking())); // 自检频率
byteBuffer.put(Byte.parseByte(deviceCheckCMD.getEnemyAndUsBranChoose()));// 带宽选择
byteBuffer.put(Byte.parseByte(deviceCheckCMD.getEnemyAndUsSelfChoose()));// 自检模式选择
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
// 帧尾
getBigPackageTheTail(byteBuffer);
// 发送信息
sendMessage(host, byteBuffer);
SysLogEntity sysLogEntity = new SysLogEntity();
String action = JsonUtils.toJson(deviceCheckCMD);
sysLogEntity.setUserAction("设备自检");
sysLogEntity.setActionDescription(action);
sysLogEntity.setCreateTime(new Date());
sysLogEntity.setHost(host);
sysLogService.saveLog(sysLogEntity);
}
}
/**
* 3.4.6.4 系统校时指令
*
* @throws IOException
*/
public void sendSystemTiming(SystemSendTimingCMD systemSendTimingCMD, String host, String updateAll,
int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendSystemTiming(systemSendTimingCMD, allHost.getHost(), "0", serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(77);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 77, shorts, shorts, backups, backups, (short) 12291, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
byteBuffer.putInt(1); // 信息长度
byteBuffer.putLong(Long.parseLong(systemSendTimingCMD.getTimeNow()));
byteBuffer.put(Byte.parseByte(systemSendTimingCMD.getTimingPattern()));
byteBuffer.putLong(Long.parseLong(systemSendTimingCMD.getTime()));
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
getBigPackageTheTail(byteBuffer);
// 发送信息
sendMessage(host, byteBuffer);
// 发送系统校时指令日志
SysLogEntity sysLogEntity = new SysLogEntity();
String str = JsonUtils.toJson(systemSendTimingCMD);
sysLogEntity.setUserAction("系统校时指令");
sysLogEntity.setActionDescription(str);
sysLogEntity.setCreateTime(new Date());
sysLogEntity.setHost(host);
sysLogService.saveLog(sysLogEntity);
}
}
/**
* 3.4.6.5 设备复位
*
* @throws IOException
*/
public void sendDeviceRestoration(DeviceRestorationSendCMD deviceRestorationSendCMD, String host, String updateAll,
int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
try {
sendDeviceRestoration(deviceRestorationSendCMD, allHost.getHost(), "0", serialNumbers);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(69);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 69, shorts, shorts, backups, backups, (short) 12292, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
byteBuffer.putInt(1); // 信息长度
byteBuffer.putLong(Long.parseLong(deviceRestorationSendCMD.getTimeNow())); // 任务流水号
byteBuffer.put(Byte.parseByte(deviceRestorationSendCMD.getExecutePattern())); // 执行方式
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
getBigPackageTheTail(byteBuffer);
// 发送信息
sendMessage(host, byteBuffer);
// 记录操作日
String type = JsonUtils.toJson(deviceRestorationSendCMD);
SysLogEntity sysLogEntity = new SysLogEntity();
sysLogEntity.setUserAction("远程开关机指令");
sysLogEntity.setCreateTime(new Date());
sysLogEntity.setHost(host);
sysLogEntity.setActionDescription(type);
sysLogService.saveLog(sysLogEntity);
}
}
/**
* 3.4.6.6 软件版本远程更新
*
* @throws IOException
*/
public void sendSoftwareUpdateCMD(String timeNow, String cmd, String softwareID, String host, String updateAll,
int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendSoftwareUpdateCMD(timeNow, cmd, softwareID, allHost.getHost(), "0", serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(72);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 72, shorts, shorts, backups, backups, (short) 12293, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
byteBuffer.putInt(2); // 信息长度
byteBuffer.putLong(Long.parseLong(timeNow)); // 任务流水号
byteBuffer.putShort(Short.parseShort(cmd)); // 指令操作码
byteBuffer.putShort(Short.parseShort(softwareID)); // 软件ID号
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
getBigPackageTheTail(byteBuffer);
// 发送信息
sendMessage(host, byteBuffer);
}
}
/**
* 3.4.6.7 设备网络参数更新指令
*
* @throws IOException
*/
public void sendDeviceNetworkCMD(SendDeviceNetWorkParam sendDeviceNetWorkParam, String host, String updateAll,
int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendDeviceNetworkCMD(sendDeviceNetWorkParam, allHost.getHost(), "0", serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(156);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 156, shorts, shorts, backups, backups, (short) 12294, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
byteBuffer.putInt(3); // 信息长度
byteBuffer.putLong(Long.parseLong(sendDeviceNetWorkParam.getTaskFlowNo())); // 任务流水号
byteBuffer.putShort(Short.parseShort(sendDeviceNetWorkParam.getCmd())); // 指令操作码
byteBuffer.putShort(Short.parseShort(sendDeviceNetWorkParam.getNetworkID())); // 网络终端ID号
// 1
String networkIP1 = sendDeviceNetWorkParam.getNetworkIP1();
byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP1)));
byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP1()));// MAC地址1
byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage1())); // 网络端口信息1
// 2
// byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP2()));
// // 网络IP地址2
String networkIP2 = sendDeviceNetWorkParam.getNetworkIP2();
byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP2)));
byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP2()));// MAC地址2
byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage2())); // 网络端口信息2
// 3
// byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP3()));
// // 网络IP地址3
String networkIP3 = sendDeviceNetWorkParam.getNetworkIP3();
byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP3)));
byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP3()));// MAC地址3
byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage3())); // 网络端口信息3
// 4
// byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP4()));
// // 网络IP地址4
String networkIP4 = sendDeviceNetWorkParam.getNetworkIP4();
byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP4)));
byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP4()));// MAC地址4
byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage4())); // 网络端口信息4
// 5
// byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP5()));
// // 网络IP地址5
String networkIP5 = sendDeviceNetWorkParam.getNetworkIP5();
byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP5)));
byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP5()));// MAC地址5
byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage5())); // 网络端口信息5
// 6
// byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkIP6()));
// // 网络IP地址6
String networkIP6 = sendDeviceNetWorkParam.getNetworkIP6();
byteBuffer.putInt(Integer.parseInt(networkIP1(networkIP6)));
byteBuffer.put(getMac(sendDeviceNetWorkParam.getNetworkMacIP6()));// MAC地址6
byteBuffer.putInt(Integer.parseInt(sendDeviceNetWorkParam.getNetworkMessage6())); // 网络端口信息6
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
getBigPackageTheTail(byteBuffer);
// 发送信息
sendMessage(host, byteBuffer);
}
}
/**
* 3.4.6.8 设备工作流程控制指令
*
* @throws IOException
*/
public void sendDeviceWorkFlowCMD(DeviceWorkFlowCMD deviceWorkFlowCMD, SystemControlCMD systemControlCMD,
Integer count, String host, String updateAll, int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendDeviceWorkFlowCMD(deviceWorkFlowCMD, systemControlCMD, count, allHost.getHost(), "0",
serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(1094);// 1094
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 1094, shorts, shorts, backups, backups, (short) 12295, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
byteBuffer.putInt(1); // 信息长度
byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getTaskFlowNo())); // 任务流水号
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getCmd())); // 指令有效标记
// 分机控制指令（雷达侦查指令）
for (int i = 1; i <= count; i++) {
byteBuffer.putShort(SocketConfig.header); // 包头
byte pulse = Byte.parseByte(deviceWorkFlowCMD.getPulse()); // 内外秒脉冲选择
byteBuffer.put(pulse);
byteBuffer.put(backups); // 备份
// 分机控制字
byte[] con = extensionControl(deviceWorkFlowCMD.getExtensionControlCharacter());
byteBuffer.put(con[0]);
byteBuffer.put(con[1]);
byteBuffer.put(backups); // 备份
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getThreshold())); // 检测门限调节
byteBuffer.putShort((Short.parseShort(deviceWorkFlowCMD.getOverallpulse())));// 上传脉冲数
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getMinamplitude()));// 最小幅度
byte c = (byte) (Integer.parseInt(deviceWorkFlowCMD.getMaxamplitude()) & 0xff);
byteBuffer.put(c);// 最大幅度
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getMinPulsewidth()));// 最小脉宽
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getMaxPulsewidth()));// 最大脉宽
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getFilterMaximumFrequency()));// 筛选最大频率
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getFilterMinimumFrequency()));// 筛选最小频率
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getShieldingMaximumFrequency()));// 屏蔽最大频率
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getShieldingMinimumFrequency()));// 屏蔽最小频率
// 默认值更新标记
if (deviceWorkFlowCMD.getDefalutUpdate().equals("0")) {
byteBuffer.put((byte) 0);
} else if (deviceWorkFlowCMD.getDefalutUpdate().equals("1")) {
byteBuffer.put((byte) 1);
}
byteBuffer.putShort(shorts); // 备份
byteBuffer.put(backups); // 备份
byteBuffer.putShort(shorts); // 备份
// 小包尾
getPackageTheTail(byteBuffer);
// 雷达系统控制指令
byteBuffer.putShort(SocketConfig.header);// 包头1ACF
byteBuffer.put(Byte.parseByte(systemControlCMD.getWorkPattern()));// 工作模式
byteBuffer.put(Byte.parseByte(systemControlCMD.getWorkPeriod())); // 工作周期
byteBuffer.putShort(Short.parseShort(systemControlCMD.getWorkPeriodNum()));// 工作周期数
byteBuffer.putShort(Short.parseShort(systemControlCMD.getInitialFrequency())); // 起始频率
byteBuffer.putShort(Short.parseShort(systemControlCMD.getTerminationFrequency())); // 终止频率
byteBuffer.putShort(Short.parseShort(systemControlCMD.getSteppedFrequency()));// 频率步进
byteBuffer.put(Byte.parseByte(systemControlCMD.getBandWidthSelection()));// 带宽选择
byteBuffer.putShort(shorts);// 备份
byteBuffer.put(backups); // 备份
byteBuffer.put(Byte.parseByte(systemControlCMD.getAntennaSelection1()));// 天线1选择(页面不展示)
byteBuffer.put(Byte.parseByte(systemControlCMD.getAntennaSelection2()));// 天线2选择(页面不展示)
byteBuffer.putShort(shorts);// 备份
// 射频一衰减(最新要求改成射频2：6-18Hz射频衰减1)
// 0:不衰减 1：衰减30db
if (systemControlCMD.getRadioFrequencyAttenuation2().equals("0")) {
byteBuffer.put((byte) 0);
} else if (systemControlCMD.getRadioFrequencyAttenuation2().equals("1")) {
byteBuffer.put((byte) 1);
}
// 射频一长电缆均衡衰减控制
// StringBuilder stringBuilders = new StringBuilder();
// String balancedAttenuationRF1 = stringBuilders.reverse()
// .append(systemControlCMD.getAttenuationControl1()).toString();
// byte bytesAttenuationRF1 = (byte) BinaryToDecimal(Integer.parseInt(balancedAttenuationRF1));
// byteBuffer.put(bytesAttenuationRF1);
byteBuffer.put(backups); // 射频一长电缆均衡衰减控制
byteBuffer.putShort(shorts); // 备份
// 射频二衰减(改名为射频1：6-18Hz射频衰减)
// 射频一衰减(最新要求改成射频2：6-18Hz射频衰减)
// 0:不衰减 1：衰减30db
if (systemControlCMD.getRadioFrequencyAttenuation1().equals("0")) {
byteBuffer.put((byte) 0);
} else if (systemControlCMD.getRadioFrequencyAttenuation1().equals("1")) {
byteBuffer.put((byte) 1);
}
// 射频二长电缆均衡衰减控制(最新)
// StringBuilder stringBuilderAttenuationRF2 = new StringBuilder();
// String balancedAttenuationRF2 = stringBuilderAttenuationRF2.reverse()
// .append(systemControlCMD.getAttenuationControl2()).toString();
// byte bytesAttenuationRF2 = (byte) BinaryToDecimal(Integer.parseInt(balancedAttenuationRF2));
// byteBuffer.put(bytesAttenuationRF2);
byteBuffer.put(backups);// 射频二长电缆均衡衰减控制
byteBuffer.putShort(shorts);
// (最新为中频2衰减0.5dB)
byte mid2 = (byte) ((byte) Double.parseDouble(systemControlCMD.getMidCut2()) * 0.5);
byteBuffer.put(mid2); // 中频衰减1
byteBuffer.putShort(shorts); // 备份
byteBuffer.put(backups);
// 中频1衰减(最新)
byte mid1 = (byte) ((byte) Double.parseDouble(systemControlCMD.getMidCut1()) * 0.5);
byteBuffer.put(mid1);
// 衰减码控制方式
byteBuffer.put(Byte.parseByte(systemControlCMD.getAttenuationCodeControlMode()));
// 自检模式选择
byteBuffer.put(Byte.parseByte(systemControlCMD.getRadarSelfChoose()));
// 备份
byteBuffer.put(backups);
// 自检源衰减
byteBuffer.put(Byte.parseByte(systemControlCMD.getSelfCheckingSourceAttenuation()));
// 脉内引导批次开关
byteBuffer.put(Byte.parseByte(systemControlCMD.getBatchNumberSwitch()));
// 脉内引导批次号
byteBuffer.put(backups);
// byteBuffer.put(Byte.parseByte(systemControlCMD.getBatchNumber()));
// 故障检测门限
byteBuffer.put(Byte.parseByte(systemControlCMD.getFaultDetectionThreshold()));
// 定时时间码
// 转换2进制
// 定时时间码
String time = systemControlCMD.getTimingTimeCode();
// 转换月
String monthString = time.substring(0, 2);
// 转换日
String dayString = time.substring(2, 4);
// 转换时
String hourString = time.substring(4, 6);
// 转换分
String minString = time.substring(6, 8);
// 转换秒
String secondString = time.substring(8, 10);
// 转2进制月
String monthBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(monthString));
int monthLeftNum = 4 - monthBinaryString.length();
for (int j = 0; j < monthLeftNum; j++) {
monthBinaryString = "0" + monthBinaryString;
}
// 转2进制日期
String dayBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(dayString));
int dayLeftNum = 5 - dayBinaryString.length();
for (int j = 0; j < dayLeftNum; j++) {
dayBinaryString = "0" + dayBinaryString;
}
// 转2进制小时
String hourBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(hourString));
int hourLeftNum = 5 - hourBinaryString.length();
for (int j = 0; j < hourLeftNum; j++) {
hourBinaryString = "0" + hourBinaryString;
}
// 转2进制分钟
String minBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(minString));
int minLeftNum = 6 - minBinaryString.length();
for (int j = 0; j < minLeftNum; j++) {
minBinaryString = "0" + minBinaryString;
}
// 转2进制秒
String secondBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(secondString));
int secondLeftNum = 11 - secondBinaryString.length();
for (int j = 0; j < secondLeftNum; j++) {
secondBinaryString = "0" + secondBinaryString;
}
String binaryString = monthBinaryString + dayBinaryString + hourBinaryString + minBinaryString
+ secondBinaryString;
int timer = Integer.parseUnsignedInt(binaryString, 2);
byteBuffer.putInt(timer);
// 单次执行指令集所需时间
byteBuffer.putShort(shorts);
// byteBuffer.putShort(Short.parseShort(systemControlCMD.getTimeRequired()));
// 小包尾
getPackageTheTail(byteBuffer);
}
// 512字节 多余补0
int a = 512;
byte[] bytes = new byte[a - count * 80];
byteBuffer.put(bytes);
for (int i = 1; i <= count; i++) {
// 敌我系统控制指令
byteBuffer.putShort(SocketConfig.header); // 包头 1ACF
byteBuffer.put(backups); // 信息包序号
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getWorkPattern1())); // 工作模式（0：自检 1：工作）
// 带宽选择解析
// String bandwidthChoose = deviceWorkFlowCMD.getBandwidthChoose();
// byteBuffer.put((byte)
// BinaryToDecimals(Long.parseLong(bandwidthChoose(bandwidthChoose))));
// byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getPulseChoice())); // 秒脉冲选择
if (deviceWorkFlowCMD.getPulseChoice().equals("0")) {
byteBuffer.put((byte) 0);
} else if (deviceWorkFlowCMD.getPulseChoice().equals("1")) {
byteBuffer.put((byte) 1);
}
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getSelfChoose()));// //自检模式选择
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getPointSelection())); // 自检频点选择
String time = deviceWorkFlowCMD.getTimeCode(); // 解析时间（同步时间）
if (time.isEmpty()) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:SSS:dd:MM:yyyy");
time = simpleDateFormat.format(new Date());
}
byte hour = Byte.parseByte(time.substring(0, 2));
byteBuffer.put(hour);
byte minute = Byte.parseByte(time.substring(3, 5));
byteBuffer.put(minute);
// 秒>毫秒>int>16进制
byteBuffer.putShort(Short.parseShort(time.substring(6, 9)));
byte day = Byte.parseByte(time.substring(10, 12));
byteBuffer.put(day);
byte month = Byte.parseByte(time.substring(13, 15));
byteBuffer.put(month);
short year = Short.parseShort(time.substring(16));
byteBuffer.putShort(year);
// 分机控制
String hierarchicalControl = deviceWorkFlowCMD.getHierarchicalControl();
byte[] temp = hierarchicalControl(hierarchicalControl);
byteBuffer.put(temp[0]);
byteBuffer.put(temp[1]);
byteBuffer.put(temp[2]);
byteBuffer.put(temp[3]);
// byteBuffer.putInt(BinaryToDecimal((int) Long.parseLong(hierarchicalControl(hierarchicalControl))));
byteBuffer.putInt(shorts); // 740全脉冲个数 备份
byteBuffer.putInt(shorts); // 837.5 PDW个数
byteBuffer.putInt(Integer.parseInt(deviceWorkFlowCMD.getPDW1030())); // 1030 PDW个数
byteBuffer.putInt(shorts); // 1059PDW个数备份
byteBuffer.putInt(Integer.parseInt(deviceWorkFlowCMD.getPDW1090())); // 1090 PDW个数
byteBuffer.putInt(Integer.parseInt(deviceWorkFlowCMD.getPDW1464())); // 1464PDW个数
byteBuffer.putInt(Integer.parseInt(deviceWorkFlowCMD.getPDW1532())); // 1532PDW个数
byteBuffer.put(backups); // 740中频个数
byteBuffer.put(backups); // 1030中频个数
byteBuffer.put(backups); // 1090中频个数
byteBuffer.put(backups); // 中频采集时间 未知
byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getFaultDetection())); // 故障检测门限（默认0x1111111111111111111111111)
byteBuffer.put(backups);// 网络包计数
byteBuffer.put(backups);// 备份
// 包尾
getPackageTheTail(byteBuffer);
}
// 512字节 多余补0
int c = 512;
byte[] byte1 = new byte[c - count * 64];
byteBuffer.put(byte1);
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和 (暂时预留)
getBigPackageTheTail(byteBuffer); // 帧尾
// 发送信息
sendMessage(host, byteBuffer);
}
}
/**
* 设备工作流程控制指令(雷达分机指令)(单发)
*
* @param host
* @param updateAll
* @param serialNumber
* @throws IOException
*/
// 1。设备工作流程控制指令(雷达分机指令)（单发）
public void sendExtensionInstructionsCMD(ArrayList<RadarDeviceCMD> deviceWorkFlowCMDs, String host,
String updateAll, int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendExtensionInstructionsCMD(deviceWorkFlowCMDs, allHost.getHost(), "0", serialNumbers);
}
} else {
// todo 1.放包头 checked sendSystemControlCmdFormat
// todo 2. 放长度 计算总长度 固定值1000多
// todo 3. 放流水号 getTaskFlowNo
// todo 4. 放指令有效标记 静态值0、1、2
// todo 5. 放第一个512 下面的代码
// todo 6. 放第二个512 这个看具体的协议
ByteBuffer byteBuffer = ByteBuffer.allocate(1094);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 大包头
sendSystemControlCmdFormat(byteBuffer, 1094, shorts, shorts, backups, backups, (short) 12295, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
// byteBuffer.putInt(1); // 信息长度
// byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getTaskFlowNo())); // 任务流水号
// byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getCmd())); // 指令有效标记
byte[] syss = new byte[14];
byteBuffer.put(syss);
for (RadarDeviceCMD deviceWorkFlowCMD : deviceWorkFlowCMDs) {
byteBuffer.putShort(SocketConfig.header); // 小包头
byte pulse = Byte.parseByte(deviceWorkFlowCMD.getPulse());// 内外秒脉冲选择
byteBuffer.put(pulse);
byteBuffer.put(backups);
// 分机控制字
byte[] con = extensionControl(deviceWorkFlowCMD.getExtensionControlCharacter()); // 分机控制字
byteBuffer.put(con[0]);
byteBuffer.put(con[1]);
byteBuffer.put(backups);
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getThreshold()));// 检测门限调节
byteBuffer.putShort((Short.parseShort(deviceWorkFlowCMD.getOverallpulse())));// 需要上传的全脉冲数
byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getMinamplitude()));// 最小幅度
byte c = (byte) (Integer.parseInt(deviceWorkFlowCMD.getMaxamplitude()) & 0xff);// 最大幅度
byteBuffer.put(c);
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getMinPulsewidth())); // 最小脉宽
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getMaxPulsewidth()));// 最大脉宽
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getFilterMaximumFrequency()));// 筛选最大频率
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getFilterMinimumFrequency()));// 筛选最小频率
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getShieldingMaximumFrequency()));// 屏蔽最大频率
byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getShieldingMinimumFrequency()));// 屏蔽最小频率
// 默认值更新标记
if (deviceWorkFlowCMD.getDefalutUpdate().equals("0")) {
byteBuffer.put((byte) 0);
} else if (deviceWorkFlowCMD.getDefalutUpdate().equals("1")) {
byteBuffer.put((byte) 1);
}
byteBuffer.putShort(shorts);
byteBuffer.put(backups);
byteBuffer.putShort(shorts);
// 包尾
getPackageTheTail(byteBuffer);
}
// 512字节 多余补0
int b = 512;
int c = b - deviceWorkFlowCMDs.size() * 32;
byte[] bytes = new byte[c];
byteBuffer.put(bytes);
// byte[] sys = new byte[48];
// byteBuffer.put(sys);
byte[] enm = new byte[512];
byteBuffer.put(enm);
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和// 校验和 (暂时预留)
getBigPackageTheTail(byteBuffer); // 帧尾
sendMessage(host, byteBuffer);
SysLogEntity sysLogEntity = new SysLogEntity();
for (RadarDeviceCMD deviceWorkFlowCMD : deviceWorkFlowCMDs) {
String type = JsonUtils.toJson(deviceWorkFlowCMD);
sysLogEntity.setActionDescription(type);
sysLogEntity.setUserAction("雷达分机指令");
sysLogEntity.setCreateTime(new Date());
sysLogEntity.setHost(host);
}
sysLogService.saveLog(sysLogEntity);
}
}
/**
* 2设备工作流程控制指令(雷达系统指令)(单发)
*
* @param host
* @param updateAll
* @param serialNumber
* @throws IOException
*/
public void sendSystemInstructionsCMD(ArrayList<SystemControlCMD> systemControlCMDs, String host, String updateAll,
int serialNumber) throws IOException {
// String message = null;
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendSystemInstructionsCMD(systemControlCMDs, allHost.getHost(), "0", serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(1094);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 大包头
sendSystemControlCmdFormat(byteBuffer, 1094, shorts, shorts, backups, backups, (short) 12295, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// byteBuffer.putInt(1); // 信息长度
// byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getTaskFlowNo())); // 任务流水号
// byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getCmd())); // 指令有效标记
byte[] byteSys = new byte[14];
byteBuffer.put(byteSys);
for (SystemControlCMD systemControlCMD : systemControlCMDs) {
// 雷达系统控制指令
byteBuffer.putShort(SocketConfig.header);// 包头1ACF
byteBuffer.put(Byte.parseByte(systemControlCMD.getWorkPattern()));// 工作模式
byteBuffer.put(Byte.parseByte(systemControlCMD.getWorkPeriod())); // 工作周期
byteBuffer.putShort(Short.parseShort(systemControlCMD.getWorkPeriodNum()));// 工作周期数
byteBuffer.putShort(Short.parseShort(systemControlCMD.getInitialFrequency())); // 起始频率
byteBuffer.putShort(Short.parseShort(systemControlCMD.getTerminationFrequency())); // 终止频率
byteBuffer.putShort(Short.parseShort(systemControlCMD.getSteppedFrequency()));// 频率步进
byteBuffer.put(Byte.parseByte(systemControlCMD.getBandWidthSelection()));// 带宽选择
byteBuffer.putShort(shorts);// 备份
byteBuffer.put(backups); // 备份
byteBuffer.put(Byte.parseByte(systemControlCMD.getAntennaSelection1()));// 天线1选择(页面不展示)
byteBuffer.put(Byte.parseByte(systemControlCMD.getAntennaSelection2()));// 天线2选择(页面不展示)
byteBuffer.putShort(shorts);// 备份
// 射频一衰减(最新要求改成射频2：6-18Hz射频衰减1)
// 0:不衰减 1：衰减30db
if (systemControlCMD.getRadioFrequencyAttenuation2().equals("0")) {
byteBuffer.put((byte) 0);
} else if (systemControlCMD.getRadioFrequencyAttenuation2().equals("1")) {
byteBuffer.put((byte) 1);
}
// 射频一长电缆均衡衰减控制
byteBuffer.put(backups); // 射频一长电缆均衡衰减控制
byteBuffer.putShort(shorts); // 备份
// 射频二衰减(改名为射频1：6-18Hz射频衰减)
// 射频一衰减(最新要求改成射频2：6-18Hz射频衰减)
// 0:不衰减 1：衰减30db
if (systemControlCMD.getRadioFrequencyAttenuation1().equals("0")) {
byteBuffer.put((byte) 0);
} else if (systemControlCMD.getRadioFrequencyAttenuation1().equals("1")) {
byteBuffer.put((byte) 1);
}
// 射频二长电缆均衡衰减控制(最新)
byteBuffer.put(backups);// 射频二长电缆均衡衰减控制
byteBuffer.putShort(shorts);
// (最新为中频2衰减0.5dB)
byte mid2 = (byte) ((byte) Double.parseDouble(systemControlCMD.getMidCut2()));
byteBuffer.put(mid2); // 中频衰减1
byteBuffer.putShort(shorts); // 备份
byteBuffer.put(backups);
// 中频1衰减(最新)
byte mid1 = (byte) ((byte) Double.parseDouble(systemControlCMD.getMidCut1()));
byteBuffer.put(mid1);
// 衰减码控制方式
byteBuffer.put(Byte.parseByte(systemControlCMD.getAttenuationCodeControlMode()));
// 自检模式选择
byteBuffer.put(Byte.parseByte(systemControlCMD.getRadarSelfChoose()));
// 备份
byteBuffer.put(backups);
// 自检源衰减
byteBuffer.put(Byte.parseByte(systemControlCMD.getSelfCheckingSourceAttenuation()));
// 脉内引导批次开关
byteBuffer.put(Byte.parseByte(systemControlCMD.getBatchNumberSwitch()));
// 脉内引导批次号
// byteBuffer.put(backups);
byteBuffer.put(Byte.parseByte(systemControlCMD.getBatchNumber()));
// 故障检测门限
byteBuffer.put(Byte.parseByte(systemControlCMD.getFaultDetectionThreshold()));
// 定时时间码
String time = systemControlCMD.getTimingTimeCode();
// 转换月
String monthString = time.substring(0, 2);
// 转换日
String dayString = time.substring(2, 4);
// 转换时
String hourString = time.substring(4, 6);
// 转换分
String minString = time.substring(6, 8);
// 转换秒
String secondString = time.substring(8, 10);
// 转2进制月
String monthBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(monthString));
int monthLeftNum = 4 - monthBinaryString.length();
for (int i = 0; i < monthLeftNum; i++) {
monthBinaryString = "0" + monthBinaryString;
}
// 转2进制日期
String dayBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(dayString));
int dayLeftNum = 5 - dayBinaryString.length();
for (int i = 0; i < dayLeftNum; i++) {
dayBinaryString = "0" + dayBinaryString;
}
// 转2进制小时
String hourBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(hourString));
int hourLeftNum = 5 - hourBinaryString.length();
for (int i = 0; i < hourLeftNum; i++) {
hourBinaryString = "0" + hourBinaryString;
}
// 转2进制分钟
String minBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(minString));
int minLeftNum = 6 - minBinaryString.length();
for (int i = 0; i < minLeftNum; i++) {
minBinaryString = "0" + minBinaryString;
}
// 转2进制秒
String secondBinaryString = Integer.toBinaryString(Integer.parseUnsignedInt(secondString));
int secondLeftNum = 11 - secondBinaryString.length();
for (int i = 0; i < secondLeftNum; i++) {
secondBinaryString = "0" + secondBinaryString;
}
String binaryString = monthBinaryString + dayBinaryString + hourBinaryString + minBinaryString
+ secondBinaryString;
int timer = Integer.parseUnsignedInt(binaryString, 2);
byteBuffer.putInt(timer);
// 单次执行指令集所需时间
byteBuffer.putShort(shorts);
// byteBuffer.putShort(Short.parseShort(systemControlCMD.getTimeRequired()));
// 小包尾
getPackageTheTail(byteBuffer); // FC1D
}
// 512字节 多余补0
int c = 512;
int cc = c - systemControlCMDs.size() * 48;
byte[] byte1 = new byte[cc];
byteBuffer.put(byte1);
byte[] enm = new byte[512];
byteBuffer.put(enm);
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和 (暂时预留)
getBigPackageTheTail(byteBuffer); // 帧尾
sendMessage(host, byteBuffer);
SysLogEntity sysLogEntity = new SysLogEntity();
for (SystemControlCMD systemControlCMD : systemControlCMDs) {
String systemControl = JsonUtils.toJson(systemControlCMD);
sysLogEntity.setActionDescription(systemControl);
sysLogEntity.setCreateTime(new Date());
sysLogEntity.setHost(host);
sysLogEntity.setUserAction("雷达系统指令");
}
sysLogService.saveLog(sysLogEntity);
}
}
/**
* 3 敌我系统控制(单发)
*
* @param host
* @param updateAll
* @param serialNumber
* @throws IOException
*/
public void sendEnemyAndUsCMD(ArrayList<EnemyAndUsCMD> enemyAndUsCMDs, String host, String updateAll,
int serialNumber) throws IOException {
if (updateAll.equals("1")) {
List<AllHost> list = hostRepository.findAll();
int serialNumbers = addSerialNum();
for (AllHost allHost : list) {
sendEnemyAndUsCMD(enemyAndUsCMDs, allHost.getHost(), "0", serialNumbers);
}
} else {
ByteBuffer byteBuffer = ByteBuffer.allocate(1094);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
int serialNumber1;
if (serialNumber == 0) {
serialNumber1 = addSerialNum();
} else {
serialNumber1 = serialNumber;
}
// 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
sendSystemControlCmdFormat(byteBuffer, 1094, shorts, shorts, backups, backups, (short) 12295, 0,
serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// 报文内容
// byteBuffer.putInt(1); // 信息长度
// byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getTaskFlowNo())); // 任务流水号
// byteBuffer.putShort(Short.parseShort(deviceWorkFlowCMD.getCmd())); // 指令有效标记
byte[] enemy = new byte[14];
byteBuffer.put(enemy);
byte[] sys = new byte[512];
byteBuffer.put(sys);
for (EnemyAndUsCMD enemyAndUsCMD : enemyAndUsCMDs) {
byteBuffer.putShort(SocketConfig.header); // 包头 1ACF
byteBuffer.put(backups); // 信息包序号
byteBuffer.put(Byte.parseByte(enemyAndUsCMD.getWorkPattern1())); // 工作模式（0：自检 1：工作）
// 带宽选择解析
String bandwidthChoose = enemyAndUsCMD.getBandwidthChoose();
byte[] temp1 = bandwidthChoose(bandwidthChoose);
byteBuffer.put(temp1[0]);
// byteBuffer.put(Byte.parseByte(deviceWorkFlowCMD.getPulseChoice())); // 秒脉冲选择
if (enemyAndUsCMD.getPulseChoice().equals("0")) {
byteBuffer.put((byte) 0);
} else if (enemyAndUsCMD.getPulseChoice().equals("1")) {
byteBuffer.put((byte) 1);
}
byteBuffer.put(Byte.parseByte(enemyAndUsCMD.getSelfChoose()));// //自检模式选择
byteBuffer.put(Byte.parseByte(enemyAndUsCMD.getPointSelection())); // 自检频点选择
String time = enemyAndUsCMD.getTimeCode(); // 解析时间（同步时间）
if (time.isEmpty()) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:SSS:dd:MM:yyyy");
time = simpleDateFormat.format(new Date());
}
byte hour = Byte.parseByte(time.substring(0, 2));
byteBuffer.put(hour);
byte minute = Byte.parseByte(time.substring(3, 5));
byteBuffer.put(minute);
// 秒>毫秒>int>16进制
byteBuffer.putShort(Short.parseShort(time.substring(6, 9)));
byte day = Byte.parseByte(time.substring(10, 12));
byteBuffer.put(day);
byte month = Byte.parseByte(time.substring(13, 15));
byteBuffer.put(month);
short year = Short.parseShort(time.substring(16));
byteBuffer.putShort(year);
// 分机控制
String hierarchicalControl = enemyAndUsCMD.getHierarchicalControl();
byte[] temp = hierarchicalControl(hierarchicalControl);
byteBuffer.put(temp[0]);
byteBuffer.put(temp[1]);
byteBuffer.put(temp[2]);
byteBuffer.put(temp[3]);
// byteBuffer.putInt(BinaryToDecimal((int) Long.parseLong(hierarchicalControl(hierarchicalControl))));
byteBuffer.putInt(shorts); // 740全脉冲个数 备份
byteBuffer.putInt(shorts); // 837.5 PDW个数
byteBuffer.putInt(Integer.parseInt(enemyAndUsCMD.getPdw1030())); // 1030 PDW个数
byteBuffer.putInt(shorts); // 1059PDW个数备份
byteBuffer.putInt(Integer.parseInt(enemyAndUsCMD.getPdw1090())); // 1090 PDW个数
byteBuffer.putInt(Integer.parseInt(enemyAndUsCMD.getPdw1464())); // 1464PDW个数
byteBuffer.putInt(Integer.parseInt(enemyAndUsCMD.getPdw1532())); // 1532PDW个数
byteBuffer.put(backups); // 740中频个数
byteBuffer.put(backups); // 1030中频个数
byteBuffer.put(Byte.parseByte(enemyAndUsCMD.getMid1090())); // 1090中频个数
byteBuffer.put(backups); // 中频采集时间 未知
// byteBuffer.putLong(Long.parseLong(deviceWorkFlowCMD.getFaultDetection())); //
// 故障检测门限（默认0x1111111111111111111111111)
short a = 4369;
for (int j = 0; j < 4; j++) {
byteBuffer.putShort(a);
}
byteBuffer.put(backups);// 网络包计数
byteBuffer.put(backups);// 备份
// 包尾
getPackageTheTail(byteBuffer);
}
// 512字节 多余补0
int c = 512;
int cc = c - enemyAndUsCMDs.size() * 64;
byte[] byte1 = new byte[c - cc];
byteBuffer.put(byte1);
byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和 (暂时预留)
getBigPackageTheTail(byteBuffer); // 帧尾
// 发送信息
sendMessage(host, byteBuffer);
SysLogEntity sysLogEntity = new SysLogEntity();
for (EnemyAndUsCMD enemyAndUsCMD : enemyAndUsCMDs) {
String enemyAndUs = JsonUtils.toJson(enemyAndUsCMD);
sysLogEntity.setActionDescription(enemyAndUs);
sysLogEntity.setCreateTime(new Date());
sysLogEntity.setHost(host);
sysLogEntity.setUserAction("敌我侦察指令");
}
sysLogService.saveLog(sysLogEntity);
}
}
/**
* 统一发送信息
*
* @throws IOException
*/
private static void sendMessage(String host, ByteBuffer byteBuffer) throws IOException {
Socket socket = (Socket) TCPThread.map.get(host);
SocketChannel socketChannel = socket.getChannel();
socketChannel.write(ByteBuffer.wrap(byteBuffer.array()));
byteBuffer.clear();
}
// 分机控制字(解析String为bit)
private byte[] extensionControl(String eccs) {
// /**
// * 因为二进制的bit0位置是最右，而接收到web端的值bit0的位置是最左，所以先将数据反转
// */
//
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("000");
// 11-12合路选择
String mergeToChoose = eccs.substring(7, 8);
switch (mergeToChoose) {
case "2":
stringBuilder.append("10");
break;
case "1":
stringBuilder.append("01");
break;
case "0":
stringBuilder.append("00");
break;
default:
throw new SystemException(SystemStatusCodeEnum.ExtensionControlCharacter_ERROR);
}
// 9-10校正表接
String revise = eccs.substring(6, 7);
switch (revise) {
case "3":
stringBuilder.append("11");
break;
case "2":
stringBuilder.append("10");
break;
case "1":
stringBuilder.append("01");
break;
case "0":
stringBuilder.append("00");
break;
default:
throw new SystemException(SystemStatusCodeEnum.ExtensionControlCharacter_ERROR);
}
// 8校正
stringBuilder.append(eccs, 5, 6);
// 6-7：分选预处理模式
String preProcessModel = eccs.substring(4, 5);
switch (preProcessModel) {
case "0":
stringBuilder.append("00");
break;
case "1":
stringBuilder.append("01");
break;
default:
throw new SystemException(SystemStatusCodeEnum.ExtensionControlCharacter_ERROR);
}
// 3-5传输原始全脉冲
String allPulse = eccs.substring(3, 4);
switch (allPulse) {
case "3":
stringBuilder.append("011");
break;
case "2":
stringBuilder.append("010");
break;
case "1":
stringBuilder.append("001");
break;
case "0":
stringBuilder.append("000");
break;
default:
throw new SystemException(SystemStatusCodeEnum.ExtensionControlCharacter_ERROR);
}
// 2合批开关
stringBuilder.append(eccs, 2, 3);
// 1.工作状态
stringBuilder.append(eccs, 1, 2);
// 0看门狗
stringBuilder.append(eccs, 0, 1);
String result = stringBuilder.toString();
byte[] bytes = new byte[2];
bytes[1] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(0, 8)));
bytes[0] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(8, 16)));
return bytes;
}
// 封装包尾信息
private void getPackageTheTail(ByteBuffer byteBuffer) {
byte[] bytes = SocketConfig.hexToByte(SocketConfig.end);
byteBuffer.put(bytes);
}
// 封装大包尾信息
private void getBigPackageTheTail(ByteBuffer byteBuffer) {
byte[] bytes = new byte[4];
bytes[0] = (byte) 143;
bytes[1] = (byte) 144;
bytes[2] = 9;
bytes[3] = (byte) 248;
byteBuffer.put(bytes);
}
// 查询当前编号,并且+1
private int addSerialNum() {
List<CMDSerialNumber> list = cmdSerialNumberRepository.findAll();
int a = 0;
if (list.size() == 1) {
for (CMDSerialNumber cmdSerialNumber : list) {
assert cmdSerialNumber != null;
a = cmdSerialNumber.getSerialNumber() + 1;
cmdSerialNumber.setSerialNumber(a);
cmdSerialNumberRepository.save(cmdSerialNumber);
}
}
return a;
}
// 在校验和的所有字节数相加
private int getByteCount(ByteBuffer byteBuffer) {
// 从目的地址开始叠加
byte[] b = byteBuffer.array();
int c = 0;
for (int a = 7; a < b.length; a++) {
String s = Integer.toBinaryString((b[a] & 0xFF) + 0x100).substring(1);
c += BinaryToDecimal(Integer.parseInt(s));
}
return c;
}
// MAC地址信息解析
private byte[] getMac(String macIP) {
return SocketConfig.hexToByte(macIP);
}
// 敌我控制指令中的带宽选择解析
private byte[] bandwidthChoose(String bandwidthChooses) {
StringBuilder stringBuilder = new StringBuilder();
// bit7
stringBuilder.append(bandwidthChooses, 3, 4);
// bit6
stringBuilder.append(bandwidthChooses, 2, 3);
stringBuilder.append("00");
String bit3 = bandwidthChooses.substring(1, 2);
switch (bit3) {
case "3":
stringBuilder.append("11");
break;
case "1":
stringBuilder.append("01");
break;
}
String bit1 = bandwidthChooses.substring(0, 1);
switch (bit1) {
case "3":
stringBuilder.append("11");
break;
case "1":
stringBuilder.append("01");
break;
}
String result = stringBuilder.toString();
byte[] bytes = new byte[1];
bytes[0] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(0, 8)));
return bytes;
}
// 敌我控制指令的分机控制
private static byte[] hierarchicalControl(String hierarchicalControl) {
// 新实现
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("00000000000");
// 17-20 1532上传选
String bit17 = hierarchicalControl.substring(5, 6);
switch (bit17) {
case "0":
stringBuilder.append("0000");
break;
case "1":
stringBuilder.append("0001");
break;
case "2":
stringBuilder.append("0010");
break;
case "3":
stringBuilder.append("0011");
break;
}
// 13-16 1532上传选
String bit13 = hierarchicalControl.substring(4, 5);
switch (bit13) {
case "0":
stringBuilder.append("0000");
break;
case "1":
stringBuilder.append("0001");
break;
case "2":
stringBuilder.append("0010");
break;
case "3":
stringBuilder.append("0011");
break;
}
// 9-12 1090上传选
String bit9 = hierarchicalControl.substring(3, 4);
switch (bit9) {
case "0":
stringBuilder.append("0000");
break;
case "1":
stringBuilder.append("0001");
break;
case "2":
stringBuilder.append("0010");
break;
case "3":
stringBuilder.append("0011");
break;
}
// 5-8 1030上传选
String bit5 = hierarchicalControl.substring(2, 3);
switch (bit5) {
case "0":
stringBuilder.append("0000");
break;
case "1":
stringBuilder.append("0001");
break;
case "2":
stringBuilder.append("0010");
break;
case "3":
stringBuilder.append("0011");
break;
}
// 1-4 740上传选
String bit1 = hierarchicalControl.substring(1, 2);
switch (bit1) {
case "0":
stringBuilder.append("0000");
break;
case "1":
stringBuilder.append("0001");
break;
case "2":
stringBuilder.append("0010");
break;
case "3":
stringBuilder.append("0011");
break;
}
stringBuilder.append(hierarchicalControl, 0, 1);
String result = stringBuilder.toString();
byte[] bytes = new byte[4];
bytes[3] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(0, 8)));
bytes[2] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(8, 16)));
bytes[1] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(16, 24)));
bytes[0] = (byte) BinaryToDecimal(Integer.parseInt(result.substring(24, 32)));
return bytes;
}
// 获取时间偏移量
public long getTimes() {
// 获取1970-1-1 到现在的毫秒数 拼接成long类型
int a = (int) System.currentTimeMillis() / 1000;
StringBuilder stringBuilder = new StringBuilder();
if (Integer.toBinaryString(a).length() < 32) {
for (int d = 0; d < 32 - Integer.toBinaryString(a).length(); d++) {
stringBuilder.append("0");
}
}
stringBuilder.append(Integer.toBinaryString(a));
for (int e = 0; e < 32; e++) {
stringBuilder.append("0");
}
return Long.parseLong(stringBuilder.toString());
}
// 网络ip地址String类型放入4byte
private static String networkIP1(String networkIP1) {
int[] ip1 = new int[4];
// 先找到IP地址字符串中.的位置
int position1 = networkIP1.indexOf(".");
int position2 = networkIP1.indexOf(".", position1 + 1);
int position3 = networkIP1.indexOf(".", position2 + 1);
// 将每个.之间的字符串转换成整型
ip1[0] = Integer.parseInt(networkIP1.substring(0, position1));
ip1[1] = Integer.parseInt(networkIP1.substring(position1 + 1, position2));
ip1[2] = Integer.parseInt(networkIP1.substring(position2 + 1, position3));
ip1[3] = Integer.parseInt(networkIP1.substring(position3 + 1));
Integer ipArr = (ip1[0] << 24) + (ip1[1] << 16) + (ip1[2] << 8) + (ip1[3]);
return ipArr.toString();
}
/**
*
* @param timeNow 报文内容 校对时间
* @param time 定时发送时间
* @param timingPattern 报文内容
* @param host 发送ip
* @param updateAll 群发
* @param serialNumber
*/
// public List<TimingTasks> addTimeSendTask(String timeNow, String time, String sendTime, String timingPattern,
// String host, String updateAll, int serialNumber) throws SchedulerException {
// List<TimingTasks> tks = new ArrayList<>();
// if (updateAll.equals("1")) {
// List<AllHost> list = hostRepository.findAll();
// int serialNumbers = addSerialNum();
// for (AllHost allHost : list) {
// addTimeSendTask(timeNow, time, sendTime, timingPattern, allHost.getHost(), "0", serialNumbers);
// }
// } else {
// ByteBuffer byteBuffer = ByteBuffer.allocate(77);
// byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
// // 如果等于0 代表该数据并非是群发,因为同批数据序号无需自增，代表群发的消息序号共享同一个序号
// int serialNumber1;
// if (serialNumber == 0) {
// serialNumber1 = addSerialNum();
// } else {
// serialNumber1 = serialNumber;
// }
// // 头部固定信息 凡是为0的数据 都只是暂定数据 待后期修改
// sendSystemControlCmdFormat(byteBuffer, 77, shorts, shorts, backups, backups, (short) 12291, 0,
// serialNumber1, 0, serialNumber1, 0, shorts, 0, shorts);
// // 报文内容
// byteBuffer.putInt(1); // 信息长度
// byteBuffer.putLong(Long.parseLong(timeNow));
// // long aaa = System.currentTimeMillis();
// byteBuffer.put(Byte.parseByte(timingPattern));
// byteBuffer.putLong(Long.parseLong(time));
// byteBuffer.putInt(getByteCount(byteBuffer)); // 校验和
// getBigPackageTheTail(byteBuffer);
//
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//
// Date sendingDateStr = null;
// String cron = "";
// try {
// sendingDateStr = sdf.parse(sendTime);
//
// cron = CronDateUtils.getCron(sendingDateStr);
// } catch (ParseException e) {
// System.err.println("定时格式不对");
// }
// String params = TopNTool.getString(byteBuffer);
//
// TimingTasks tasks = new TimingTasks();
// tasks.setJobGroup("bwjs");
// tasks.setJobName(tasks.getId());
// tasks.setParams(params);
// tasks.setState(1);
// tasks.setHost(host);
// tasks.setCron(cron);
// TimingTasks ua = timingTaskRepository.save(tasks);
System.out.println(refresh(ua));
// tks.add(ua);
// }
// return tks;
// }
}
接收包数据的代码
package com.rengu.project.integrationoperations.service;
import com.rengu.project.integrationoperations.entity.*;
import com.rengu.project.integrationoperations.enums.SystemStatusCodeEnum;
import com.rengu.project.integrationoperations.repository.HostRepository;
import com.rengu.project.integrationoperations.repository.SysErrorLogRepository;
import com.rengu.project.integrationoperations.util.SocketConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.text.DecimalFormat;
import java.util.*;
/**
* 接收c++发送数据，进行解析 author : yaojiahao Date: 2019/7/8 11:19
**/
@Service
@Slf4j
public class WebReceiveToCService {
private final HostRepository hostRepository;
private final SimpMessagingTemplate simpMessagingTemplate;
private static DecimalFormat df2 = new DecimalFormat("#.00");
private static DecimalFormat jd = new DecimalFormat("#.0000");
private static String radarString = "";
private final SysErrorLogService sysErrorLogService;
Map<String, String> globalMap = new HashMap<String, String>();
Map<String, String> globalId = new HashMap<String, String>(); // 全局站id
public WebReceiveToCService(HostRepository hostRepository, SimpMessagingTemplate simpMessagingTemplate,
SysErrorLogService sysErrorLogService) {
this.hostRepository = hostRepository;
this.simpMessagingTemplate = simpMessagingTemplate;
this.sysErrorLogService = sysErrorLogService;
}
// 储存或更新当前连接服务端的IP地址
public void allHost(String hosts) {
List<AllHost> allHostList = hostRepository.findAll();
int size = hostRepository.findByHostNotLike("无").size();
for (AllHost allHost : allHostList) {
if (allHost.getHost().equals("无")) {
if (!hasHostIP(hosts)) {
allHost.setHost(hosts);
//获取站id保存
// if (globalId.get("hostID").equals(null) && globalId.get("hostID") == "") {
// allHost.setStationID("0");
// } else {
// allHost.setStationID(String.valueOf(globalId.get("hostID")));
// }
allHost.setStationID(String.valueOf(globalId.get("hostID")));
Map<Object, Object> map = new HashMap<>();
map.put("device", size + 1);
map.put("message", "一台新的设备已入库");
hostRepository.save(allHost);
simpMessagingTemplate.convertAndSend("/deviceConnect/send", map);
return;
}
}
}
if (!hasHostIP(hosts)) {
AllHost allHosts = new AllHost();
allHosts.setHost(hosts);
allHosts.setStationID(String.valueOf(globalId.get("hostID")));
AllHost allHost = hostRepository.findMaxByNum();
allHosts.setNum(allHost.getNum() + 1);
hostRepository.save(allHosts);
}
}
// 解析报文固定信息
@Async
public Map<String, Number> receiveFixedInformation(ByteBuffer byteBuffer) {
Map<String, Number> map = new HashMap<>();
map.put("header", byteBuffer.getInt(0)); // 报文头
map.put("dataLength", byteBuffer.getInt(4)); // 当前包数据长度
map.put("targetHost", byteBuffer.getShort(8)); // 目的地址
map.put("sourceHost", byteBuffer.getShort(10)); // 源地址
map.put("regionID", byteBuffer.get(12)); // 域ID
map.put("themeID", byteBuffer.get(13)); // 主题ID
map.put("messageCategory", byteBuffer.getShort(14)); // 信息类别
map.put("transmitDate", byteBuffer.getLong(16)); // 发报日期时间
map.put("serialNumber", byteBuffer.getInt(24)); // 序列号
map.put("bagTotal", byteBuffer.getInt(28)); // 包总数
map.put("currentBagNo", byteBuffer.getInt(32)); // 当前包号
map.put("dataTotalLength", byteBuffer.getInt(36)); // 数据总长度
map.put("versionNumber", byteBuffer.getShort(40)); // 版本号
map.put("backups1", byteBuffer.getInt(42)); // 保留字段
map.put("backups2", byteBuffer.getShort(46)); // 保留字段
return map;
}
/**
* 设备
*/
// @Async
public void receiveSocketHandler1(ByteBuffer byteBuffer, String host) {
int messageCategorys = byteBuffer.order(ByteOrder.LITTLE_ENDIAN).getShort(14);
System.out.println("接收到" + messageCategorys);
// Map<String, Number> mapFixation = receiveFixedInformation(byteBuffer);
// String sourceHost = Integer.toHexString(Short.toUnsignedInt(mapFixation.get("sourceHost").shortValue()));
// globalId.put("hostID", sourceHost);
switch (messageCategorys) {
case 12289:
System.out.println("接收到" + host + "的心跳指令");
receiveHeartbeatCMD(byteBuffer, host); // 心跳指令
break;
case 12545:
System.out.println("接收到" + host + "的上报心跳信息");
uploadHeartBeatMessage(byteBuffer, host);// 上报心跳信息
break;
case 12546:
uploadSelfInspectionResult(byteBuffer, host); //
break;
case 12549:
uploadSoftwareVersionMessage(byteBuffer, host);// 软件版本远程更新
break;
case 12550:
uploadDeviceNetWorkParamMessage(byteBuffer, host);//
break;
case 12576:
uploadRadarSubSystemWorkStatusMessage(byteBuffer, host);//
break;
case 12577:
uploadEnemyAndUsPackageMessage(byteBuffer, host);//
break;
default:
// test(byteBuffer, host);
break;
}
}
/**
* 3.4.6.2 心跳指令
*/
private void receiveHeartbeatCMD(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> map = receiveFixedInformation(byteBuffer);
Map<String, Object> map1 = new HashMap<>();
// map.put("messageLength",byteBuffer.getInt(48));// 信息长度
// map1.put("taskFlowNo", byteBuffer.getLong(52));// 任务流水号
map1.put("heartbeat", byteBuffer.get(60));// 心跳
// map.put("verify", byteBuffer.getInt(61));// 校验和
// map.put("messageEnd", byteBuffer.getInt(65));// 结尾
map1.put("host", host);
ResultEntity resultEntity = new ResultEntity(SystemStatusCodeEnum.SUCCESS, map1);
simpMessagingTemplate.convertAndSend("/receiveHeartbeatCMD/sendToHeartBeat", resultEntity);
}
/**
* 3.4.6.9 上传心跳信息
*/
private void uploadHeartBeatMessage(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> mapFixation = receiveFixedInformation(byteBuffer);
Map<String, String> result = new HashMap<String, String>(); // 解析系统工作状态
byte systemWorkStatus = byteBuffer.get(60);
String cardState = getCardState(systemWorkStatus);
String sourceHost = Integer.toHexString(Short.toUnsignedInt(mapFixation.get("sourceHost").shortValue()));
result.put("cardState", cardState);
result.put("host", host);
result.put("stationId", sourceHost);
globalId.put("hostID", sourceHost);
simpMessagingTemplate.convertAndSend("/uploadHeartBeatMessage/send",
new ResultEntity(SystemStatusCodeEnum.SUCCESS, result));
saveErrorLog(host, cardState);
}
/**
* 3.4.6.10 上报自检结果
*/
private void uploadSelfInspectionResult(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> map = receiveFixedInformation(byteBuffer);
Map<String, String> map1 = new HashMap<String, String>();
int messageLength = byteBuffer.getInt(48); // 信息长度
long taskFlowNo = byteBuffer.getLong(52); // 任务流水号
map1.put("taskFlowNo", String.valueOf(taskFlowNo));
byte systemWorkStatus = byteBuffer.get(60); // 自检结果
// getDouble(systemWorkStatus);
String systemWork = Integer.toBinaryString(systemWorkStatus);
StringBuilder stringBuilder2 = new StringBuilder(systemWork);
stringBuilder2.reverse();
StringBuilder stringBuilder4 = new StringBuilder();
int a1 = 8 - systemWork.length();
String bString1 = "0";
for (int i = 0; i < a1; i++) {
// stringBuilder3.append(b);
systemWork = bString1 + systemWork;
}
// 每两位转10进制数值int输出
for (int i = 4; i < 8; i += 2) {
String rstr = systemWork.substring(i, i + 2);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
stringBuilder4.append(ss);
}
map1.put("systemWorkStatus", String.valueOf(stringBuilder4.reverse()));
// map1.put("systemWorkStatus", String.valueOf(systemWorkStatus));
byteBuffer.position(61);
// 备份
byte[] selfChoose = new byte[3];
byteBuffer.get(selfChoose);
BigDecimal bigDecimal = null;
// 雷达子系统自检信息
// 通道1频率1
int radarChannel1Frequency = byteBuffer.getInt(64);
bigDecimal = new BigDecimal((float) radarChannel1Frequency * 0.1);
map1.put("radarChannel1Frequency", bigDecimal.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 脉宽1
int radarChannel1PulseWidth = byteBuffer.getInt(68);
bigDecimal = new BigDecimal((float) radarChannel1PulseWidth * 0.008);
map1.put("radarChannel1PulseWidth", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 重周1
int radarChannel1RepeatPeriod = byteBuffer.getInt(72);
bigDecimal = new BigDecimal((float) radarChannel1RepeatPeriod * 0.008);
map1.put("radarChannel1RepeatPeriod", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 数字幅度1
byte radarChannel1NumRange = byteBuffer.get(76);
bigDecimal = new BigDecimal((float) Byte.toUnsignedInt(radarChannel1NumRange) * 0.25);
map1.put("radarChannel1NumRange", bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 通道2频率
int radarChannel2Frequency = byteBuffer.getInt(77);
bigDecimal = new BigDecimal((float) radarChannel2Frequency * 0.1);
map1.put("radarChannel2Frequency", bigDecimal.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 脉宽
int radarChannel2PulseWidth = byteBuffer.getInt(81);
bigDecimal = new BigDecimal((float) radarChannel2PulseWidth * 0.008);
map1.put("radarChannel2PulseWidth", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 重周
int radarChannel2RepeatPeriod = byteBuffer.getInt(85);
bigDecimal = new BigDecimal((float) radarChannel2RepeatPeriod * 0.008);
map1.put("radarChannel2RepeatPeriod", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 通道2数字幅度
byte radarChannel2NumRange = byteBuffer.get(89);
bigDecimal = new BigDecimal((float) Byte.toUnsignedInt(radarChannel2NumRange) * 0.25);
map1.put("radarChannel2NumRange", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
/** 敌我子系统自检信息 */
// 频率
int enemyAndUsFrequency = byteBuffer.getInt(90);
bigDecimal = new BigDecimal((float) enemyAndUsFrequency * 0.0625);
map1.put("enemyAndUsFrequency", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 脉宽
int enemyAndUsPulseWidth = byteBuffer.getInt(94);
bigDecimal = new BigDecimal((float) enemyAndUsPulseWidth * 0.00416667);
map1.put("enemyAndUsPulseWidth", bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue() + "");
// 重周
int enemyAndUsRepeatPeriod = byteBuffer.getInt(98);
map1.put("enemyAndUsRepeatPeriod", String.valueOf(enemyAndUsRepeatPeriod));
// 数字幅度
byte enemyAndUsNumRange = byteBuffer.get(102);
map1.put("enemyAndUsNumRange", String.valueOf(enemyAndUsNumRange));
int verify = byteBuffer.getInt(103); // 校验和
int messageEnd = byteBuffer.getInt(107); // 报文尾
map1.put("host", host);
simpMessagingTemplate.convertAndSend("/uploadSelfInspectionResult/send",
new ResultEntity(SystemStatusCodeEnum.SUCCESS, map1));
}
/**
* 3.4.6.11 上报软件版本信息包 (软件版本信息表128字节待定,已用72字节)
*/
private void uploadSoftwareVersionMessage(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> map = receiveFixedInformation(byteBuffer);
Map<String, String> map1 = new HashMap<>();
int messageLength = byteBuffer.getInt(48);
long taskFlowNo = byteBuffer.getLong(52);
short cmd = byteBuffer.getShort(60);
// 软件版本信息表 ()
// 雷达加载版本号(先展示前72个字节)
int lateralFPGA = byteBuffer.getInt(62); // 侧向FPGA_A版本号
String lateral = Integer.toHexString(lateralFPGA).toUpperCase();
map1.put("lateralFPGA", String.valueOf(lateral));
int lateralZ7PS = byteBuffer.getInt(66); // 侧向Z7-PS版本号
String lateral2 = Integer.toHexString(lateralZ7PS).toUpperCase();
map1.put("lateralZ7PS", lateral2);
int crimesFPGA = byteBuffer.getInt(70);
String crimes = Integer.toHexString(crimesFPGA).toUpperCase();
map1.put("crimesFPGA", crimes);
int crimesZ7PS = byteBuffer.getInt(74);
String crimes2 = Integer.toHexString(crimesZ7PS).toUpperCase();
map1.put("crimesZ7PS", crimes2);
int signalFPGA = byteBuffer.getInt(78);
String signal = Integer.toHexString(signalFPGA).toUpperCase();
map1.put("signalFPGA", signal);
int systemFPGA = byteBuffer.getInt(82);
String system = Integer.toHexString(systemFPGA).toUpperCase();
map1.put("systemFPGA", system);
int lateralFPGB = byteBuffer.getInt(86);
String lateral3 = Integer.toHexString(lateralFPGB).toUpperCase();
map1.put("lateralFPGB", lateral3);
int lateralZ7PL = byteBuffer.getInt(90);
String lateral4 = Integer.toHexString(lateralZ7PL).toUpperCase();
map1.put("lateralZ7PL", lateral4);
int crimesFPGB = byteBuffer.getInt(94);
String crimes3 = Integer.toHexString(crimesFPGB).toUpperCase();
map1.put("crimesFPGB", crimes3);
int crimesZ7PL = byteBuffer.getInt(98);
String crimes4 = Integer.toHexString(crimesZ7PL).toUpperCase();
map1.put("crimesZ7PL", crimes4);
int signalDSP = byteBuffer.getInt(102);
String signaldsp = Integer.toHexString(signalDSP).toUpperCase();
map1.put("signalDSP", signaldsp);
int systemDSP = byteBuffer.getInt(106);
String systemdsp = Integer.toHexString(systemDSP).toUpperCase();
map1.put("systemDSP", systemdsp);
// 敌我加载版本号
int masterControlFPGA1 = byteBuffer.getInt(110);
String master = Integer.toHexString(masterControlFPGA1).toUpperCase();
map1.put("masterControlFPGA1", master);
int masterControlDSP = byteBuffer.getInt(114);
String master1 = Integer.toHexString(masterControlDSP).toUpperCase();
map1.put("masterControlDSP", master1);
int inspectFPGA2 = byteBuffer.getInt(118);
String inspect = Integer.toHexString(inspectFPGA2).toUpperCase();
map1.put("inspectFPGA2", inspect);
int masterControlFPGA2 = byteBuffer.getInt(122);
String masterControl = Integer.toHexString(masterControlFPGA2).toUpperCase();
map1.put("masterControlFPGA2", masterControl);
int inspectFPGA1 = byteBuffer.getInt(126);
String inspectfpga = Integer.toHexString(inspectFPGA1).toUpperCase();
map1.put("inspectFPGA1", inspectfpga);
int inspectFPGA = byteBuffer.getInt(130);
String inspect2 = Integer.toHexString(inspectFPGA).toUpperCase();
map1.put("inspectFPGA", inspect2);
byteBuffer.position(134);
// 信息表长度占256，版本信息占了72个字节
byte[] bytes1 = new byte[184];
byteBuffer.get(bytes1);
int verify = byteBuffer.getInt(318); // 校验和
int messageEnd = byteBuffer.getInt(322); // 报文尾
map1.put("host", host);
simpMessagingTemplate.convertAndSend("/uploadSoftwareVersionMessage/send",
new ResultEntity(SystemStatusCodeEnum.SUCCESS, map1));
}
/**
* 3.4.6.12 上传设备网络参数信息包
*/
private void uploadDeviceNetWorkParamMessage(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> map = receiveFixedInformation(byteBuffer);
SendDeviceNetWorkParam sendDeviceNetWorkParam = new SendDeviceNetWorkParam();
int messageLength = byteBuffer.getInt(48);
long taskFlowNo = byteBuffer.getLong(52);
short cmd = byteBuffer.getShort(60);
short networkID = byteBuffer.getShort(62); // 网络终端ID号
sendDeviceNetWorkParam.setNetworkID(String.valueOf(networkID));
byteBuffer.position(64);
byte[] networkIP1s = new byte[4];
byteBuffer.get(networkIP1s);
sendDeviceNetWorkParam.setNetworkIP1(getIP(networkIP1s)); // 网络IP地址1
String mac1 = getMac(byteBuffer.getShort(68), byteBuffer.getInt(70)); // 网络MAC地址1
sendDeviceNetWorkParam.setNetworkMacIP1(mac1);
int networkMessage1 = byteBuffer.getInt(74); // 网络端口信息1
sendDeviceNetWorkParam.setNetworkMessage1(String.valueOf(networkMessage1));
byteBuffer.position(78);
byte[] networkIP2s = new byte[4];
byteBuffer.get(networkIP2s);
sendDeviceNetWorkParam.setNetworkIP2(getIP(networkIP2s)); // 网络IP地址2
String mac2 = getMac(byteBuffer.getShort(82), byteBuffer.getInt(86)); // 网络MAC地址2
sendDeviceNetWorkParam.setNetworkMacIP2(mac2);
int networkMessage2 = byteBuffer.getInt(88); // 网络端口信息2
sendDeviceNetWorkParam.setNetworkMessage2(String.valueOf(networkMessage2));
byteBuffer.position(92);
byte[] networkIP3s = new byte[4];
byteBuffer.get(networkIP3s);
sendDeviceNetWorkParam.setNetworkIP3(getIP(networkIP3s)); // 网络IP地址3
String mac3 = getMac(byteBuffer.getShort(96), byteBuffer.getInt(98)); // 网络MAC地址3
sendDeviceNetWorkParam.setNetworkMacIP3(mac3);
int networkMessage3 = byteBuffer.getInt(102); // 网络端口信息3
sendDeviceNetWorkParam.setNetworkMessage3(String.valueOf(networkMessage3));
byteBuffer.position(106);
byte[] networkIP4s = new byte[4];
byteBuffer.get(networkIP4s);
sendDeviceNetWorkParam.setNetworkIP4(getIP(networkIP4s)); // 网络IP地址4
String mac4 = getMac(byteBuffer.getShort(110), byteBuffer.getInt(112)); // 网络MAC地址4
sendDeviceNetWorkParam.setNetworkMacIP4(mac4);
int networkMessage4 = byteBuffer.getInt(116); // 网络端口信息4
sendDeviceNetWorkParam.setNetworkMessage4(String.valueOf(networkMessage4));
byteBuffer.position(120);
byte[] networkIP5s = new byte[4];
byteBuffer.get(networkIP5s);
sendDeviceNetWorkParam.setNetworkIP5(getIP(networkIP5s)); // 网络IP地址5
String mac5 = getMac(byteBuffer.getShort(124), byteBuffer.getInt(126)); // 网络MAC地址5
sendDeviceNetWorkParam.setNetworkMacIP5(mac5);
int networkMessage5 = byteBuffer.getInt(130); // 网络端口信息5
sendDeviceNetWorkParam.setNetworkMessage5(String.valueOf(networkMessage5));
byteBuffer.position(134);
byte[] networkIP6s = new byte[4];
byteBuffer.get(networkIP6s);
sendDeviceNetWorkParam.setNetworkIP6(getIP(networkIP6s)); // 网络IP地址6
String mac6 = getMac(byteBuffer.getShort(138), byteBuffer.getInt(140)); // 网络MAC地址6
sendDeviceNetWorkParam.setNetworkMacIP6(mac6);
int networkMessage6 = byteBuffer.getInt(144); // 网络端口信息6
sendDeviceNetWorkParam.setNetworkMessage6(String.valueOf(networkMessage6));
// 结尾
int verify = byteBuffer.getInt(148); // 校验和
int messageEnd = byteBuffer.getInt(152); // 报文尾
List<Object> list = new ArrayList<>();
list.add(host);
list.add(sendDeviceNetWorkParam);
// 根据设备发送指定信息
simpMessagingTemplate.convertAndSend("/uploadDeviceNetWorkParamMessage/send",
new ResultEntity(SystemStatusCodeEnum.SUCCESS, list));
}
/**
* 3.4.6.13 上报雷达子系统工作状态信息包 雷达子系统状态信息
*/
@Async
public void uploadRadarSubSystemWorkStatusMessage(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> map = receiveFixedInformation(byteBuffer);
Map<String, String> map1 = new HashMap<>();
int messageLength = byteBuffer.getInt(48);
long taskFlowNo = byteBuffer.getLong(52);
// 雷达子系统状态信息
short header = (short) SocketConfig.BinaryToDecimal(byteBuffer.getShort(60)); // 帧有效标记
short dataType = byteBuffer.getShort(62); // 数据类型
int dataLength = byteBuffer.getInt(64); // 数据长度
/* 系统控制信息begin */
// 包头 53f8(2)
short heardSys = byteBuffer.getShort(68);
map1.put("heardSys", Integer.toHexString(Short.toUnsignedInt(heardSys)));
// 雷达信息包序号 (2)
short systemControl = byteBuffer.getShort(70);
map1.put("systemControl", Short.toUnsignedInt(systemControl) + "");
// TODO 时间码 8
long timeCodings = byteBuffer.getLong(72);
String timeCode = longToBinaryString(timeCodings);
String resultString = "";
// 年
resultString = resultString + String.valueOf(Short.parseShort(timeCode.substring(0, 16), 2)) + "/";
// 月
resultString = resultString + String.valueOf(Short.parseShort(timeCode.substring(16, 24), 2)) + "/";
// 日
resultString = resultString + String.valueOf(Short.parseShort(timeCode.substring(24, 32), 2)) + " ";
// 时
resultString = resultString + String.valueOf(Short.parseShort(timeCode.substring(56, 64), 2)) + ":";
// 分
resultString = resultString + String.valueOf(Short.parseShort(timeCode.substring(48, 56), 2)) + ":";
// 秒
resultString = resultString + String.valueOf(Short.parseShort(timeCode.substring(32, 48), 2));
map1.put("timeCodings", resultString);
// 工作方式(1) <string>自检</string>
byte workPattern = byteBuffer.get(80);
map1.put("workPattern", Byte.toUnsignedInt(workPattern) + "");
// 带宽选择(1)
byte bandWidthSelection = byteBuffer.get(81);
map1.put("bandWidthSelection", Byte.toUnsignedInt(bandWidthSelection) + "");
// 工作周期数(1)
byte workNums = byteBuffer.get(82);
map1.put("workNums", Byte.toUnsignedInt(workNums) + "");
// 工作周期长度( 1
byte workPeriodNum = byteBuffer.get(83);
map1.put("workPeriodNum", Byte.toUnsignedInt((byte) (workPeriodNum * 50)) + "");
// 频段码--2
short frequencyPeriodNum = byteBuffer.getShort(84);
map1.put("frequencyPeriodNum", Short.toUnsignedInt(frequencyPeriodNum) + "");
// 测向天线选择-- 1
byte cxChooce = byteBuffer.get(86);
map1.put("cxChooce", Byte.toUnsignedInt(cxChooce) + "");
// 侦察天线选择--1
byte zcChoose = byteBuffer.get(87);
map1.put("zcChoose", Byte.toUnsignedInt(zcChoose) + "");
// 射频1衰减--1
byte sp1 = byteBuffer.get(88);
map1.put("sp1", Byte.toUnsignedInt(sp1) + "");
// 射频2衰减--1
byte sp2 = byteBuffer.get(89);
map1.put("sp2", Byte.toUnsignedInt(sp2) + "");
// 中频2衰减--1
byte mid1 = byteBuffer.get(90);
map1.put("mid1", Byte.toUnsignedInt(mid1) + "");
// 中频1衰减--1
byte mid2 = byteBuffer.get(91);
map1.put("mid2", Byte.toUnsignedInt(mid2) + "");
byteBuffer.position(92);
// 备份--2
byte[] byteSys = new byte[2];
byteBuffer.get(byteSys);
// 脉冲筛选最小频率--2
short filterMinimumFrequency = byteBuffer.getShort(94);
map1.put("filterMinimumFrequency", Short.toUnsignedInt(filterMinimumFrequency) + "");
// 脉冲筛选最大频率--2
short filterMaximumFrequency = byteBuffer.getShort(96);
map1.put("filterMaximumFrequency", Short.toUnsignedInt(filterMaximumFrequency) + "");
// 脉冲筛选最小幅度--1
int minamplitude = Byte.toUnsignedInt(byteBuffer.get(98));
map1.put("minamplitude", Integer.toUnsignedString((int) (minamplitude * 0.5)));
// 脉冲筛选最大幅度--1
int maxamplitude = Byte.toUnsignedInt(byteBuffer.get(99));
map1.put("maxamplitude", Integer.toUnsignedString((int) (maxamplitude * 0.5)));
// 脉冲筛选最小脉宽/100ns --2
short minPulsewidth = byteBuffer.getShort(100);
map1.put("minPulsewidth", Short.toUnsignedInt(minPulsewidth) + "");
// 脉冲筛选最大脉宽/100ns --2
short maxPulsewidth = byteBuffer.getShort(102);
map1.put("maxPulsewidth", Short.toUnsignedInt(maxPulsewidth) + "");
byteBuffer.position(104);
// 信道屏蔽</16
byte[] information = new byte[16];
byteBuffer.get(information);
// 脉内引导批次号开关</1
byte open = byteBuffer.get(120);
map1.put("open", Byte.toUnsignedInt(open) + "");
// 脉内引导批次号</1
byte openNum = byteBuffer.get(121);
map1.put("openNum", Byte.toUnsignedInt(openNum) + "");
// 需要上传的全脉冲数/--2
short upNum = byteBuffer.getShort(122);
map1.put("upNum", Short.toUnsignedInt(upNum) + "");
// 分机控制----2
short defendController = byteBuffer.getShort(124);
String defend = getFenjiControl(defendController);
map1.put("defendController", defend);
// 设备编号--1
byte deviceNo2 = byteBuffer.get(126);
map1.put("deviceNo2", Byte.toUnsignedInt(deviceNo2) + radarString);
// 检测门限调节 1
byte textDoor = byteBuffer.get(127);
map1.put("textDoor", Byte.toUnsignedInt(textDoor) + radarString);
byteBuffer.position(128);
// 备份 4
byte[] backupSys = new byte[4];
byteBuffer.get(backupSys);
// byte[] bytes2 = new byte[64]; // GPS数据
// byteBuffer.get(bytes2);
/* GPS数据begin */
// GPS包头 4
int GPSHeader = byteBuffer.getInt(132);
map1.put("GPSHeader", Integer.toHexString(GPSHeader));
// 时
byte hour = byteBuffer.get(136);
map1.put("hour", Byte.toUnsignedInt(hour) + "");
// 分
byte mini = byteBuffer.get(137);
map1.put("mini", Byte.toUnsignedInt(mini) + "");
// 秒
short second = byteBuffer.getShort(138);
map1.put("second", Short.toUnsignedInt(second) + "");
// 日
byte days = byteBuffer.get(140);
map1.put("days", Byte.toUnsignedInt(days) + "");
// 月
byte mouths = byteBuffer.get(141);
map1.put("mouths", Byte.toUnsignedInt(mouths) + "");
// 年
short year = byteBuffer.getShort(142);
map1.put("year", Short.toUnsignedInt(year) + "");
// 经度 4
float longitude = byteBuffer.getFloat(144);
map1.put("longitude", String.valueOf(jd.format(longitude)));
// 纬度 4
float latitude = byteBuffer.getFloat(148);
map1.put("latitude", String.valueOf(jd.format(latitude)));
// 高度
int height = byteBuffer.getInt(152);
// map1.put("height", jd.format(Integer.toUnsignedString(height)));
map1.put("height", String.valueOf(jd.format(height)));
// 参考源 1
byte referenceSource = byteBuffer.get(156);
map1.put("referenceSource", Byte.toUnsignedInt(referenceSource) + "");
// 同步状态 1
byte synchronizationState = byteBuffer.get(157);
map1.put("synchronizationState", Byte.toUnsignedInt(synchronizationState) + "");
// 输出状态 1
byte outState = byteBuffer.get(158);
map1.put("outState", Byte.toUnsignedInt(outState) + "");
// 时区选择 1
byte hourChoose = byteBuffer.get(159);
map1.put("hourChoose", Byte.toUnsignedInt(hourChoose) + "");
// 同步精度 4
int synchronizationAccuracy = byteBuffer.getInt(160);
map1.put("synchronizationAccuracy", Integer.toUnsignedString(synchronizationAccuracy));
// 北纬/南纬 1
byte latitudeTips = byteBuffer.get(164);
map1.put("latitudeTips", Byte.toUnsignedInt(latitudeTips) + "");
// 东经/西经 1
byte longitudeTips = byteBuffer.get(165);
map1.put("longitudeTips", Byte.toUnsignedInt(longitudeTips) + "");
// 校验和 1
byte total = byteBuffer.get(166);
map1.put("total", Byte.toUnsignedInt(total) + "");
byteBuffer.position(167);
// GPS数据备份 29
byte[] byteGPSSys = new byte[29];
byteBuffer.get(byteGPSSys);
/* GPSend */
// 发方节点号 1
byte faNodeNo = byteBuffer.get(196);
map1.put("faNodeNo", Byte.toUnsignedInt(faNodeNo) + "");
byte souNodeNo = byteBuffer.get(197); // 收方节点号 1
map1.put("receiveNodeNo", Byte.toUnsignedInt(souNodeNo) + "");
short feedbackNo = byteBuffer.getShort(198); // 反馈指令序号 2
// int feed = getNum(feedbackNo);
map1.put("feedbackNo", Short.toUnsignedInt(feedbackNo) + radarString);
short cmdStatus = byteBuffer.getShort(200); // 指令接收状态 2
StringBuilder cmdRecive = getShort(cmdStatus);
map1.put("cmdStatus", String.valueOf(cmdRecive));
short taskNo = byteBuffer.getShort(202); // 任务编号 2
map1.put("taskNo", Short.toUnsignedInt(taskNo) + radarString);
short frontEndWorkTemperature = byteBuffer.getShort(204); // 前端工作温度 2
map1.put("frontEndWorkTemperature", String.valueOf(df2.format(frontEndWorkTemperature * 0.0078125)));
short fenjiWorkTemperature = byteBuffer.getShort(206); // 分机工作温度 2
map1.put("fenjiWorkTemperature", String.valueOf(df2.format(fenjiWorkTemperature * 0.0078125)));
/* 分机工作状态begin */
long fenJiWorkStatus = byteBuffer.getLong(208); // 分机工作状态 8
// StringBuilder stateWork = getWorkStates(fenJiWorkStatus);
String stateWork = radarWorkState(fenJiWorkStatus);
map1.put("fenJiWorkStatus", stateWork);
/* 分机工作状态end */
int channel1CxNum = byteBuffer.getInt(216); // 通道1(CX)全脉冲个数统计 4
map1.put("channel1CxNum", Integer.toUnsignedString(channel1CxNum));
int channel2ZcNum = byteBuffer.getInt(220); // 通道2(ZC)全脉冲个数统计 4
map1.put("channel2ZcNum", Integer.toUnsignedString(channel2ZcNum));
// 通道1(CX)辐射源个数统计 2
short radiationChannel1CxNum = byteBuffer.getShort(224);
map1.put("radiationChannel1CxNum", Short.toUnsignedInt(radiationChannel1CxNum) + radarString);
// 通道2(ZC)辐射源个数统计 2
short radiationChannel2ZcNum = byteBuffer.getShort(226);
map1.put("radiationChannel2ZcNum", Short.toUnsignedInt(radiationChannel2ZcNum) + radarString);
byte deviceNo = byteBuffer.get(228); // 设备编号
// 设备编号
String deviceNoString = Integer.toBinaryString((deviceNo & 0xFF) + 0x100).substring(1);
StringBuilder stringBuilder1 = new StringBuilder(deviceNoString);
stringBuilder1.reverse();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(stringBuilder1, 0, 4);
int bit7_4 = Integer.parseInt(stringBuilder1.substring(4, 6));
// bit7-bit4 0：520项目 1：西沙改 2：大车 3：舰载
if (bit7_4 == 0) {
stringBuilder.append("0");
} else if (bit7_4 == 1) {
stringBuilder.append("1");
} else if (bit7_4 == 10) {
stringBuilder.append("2");
} else if (bit7_4 == 11) {
// 3在2进制中为11
stringBuilder.append("3");
}
map1.put("deviceNo", stringBuilder.toString());
byteBuffer.position(229);
// 备份 3
byte[] backups3 = new byte[3];
byteBuffer.get(backups3);
// 分机控制状态 - 看门狗、合路选择
short defendState = byteBuffer.getShort(232);
String fenji = getFenjiState(defendState);
map1.put("defendState", fenji);
byteBuffer.position(234);
// 备份 2
byte[] backups2 = new byte[2];
byteBuffer.get(backups2);
// 6-18HHz长电缆均衡衰减控制1 1
byte hhzz6_18_1 = byteBuffer.get(236);
map1.put("hhzz6_18_1", Byte.toUnsignedInt(hhzz6_18_1) + radarString);
// 6-18HHz长电缆均衡衰减控制2 1
byte hhzz6_18_2 = byteBuffer.get(237);
map1.put("hhzz6_18_2", Byte.toUnsignedInt(hhzz6_18_2) + radarString);
// 通道2（ZC）中频衰减 1
byte channel2ZcMidCut = byteBuffer.get(238);
map1.put("channel2ZcMidCut", Byte.toUnsignedInt(channel2ZcMidCut) + radarString);
// 通道1（CX）中频衰减 1
byte channel1CxMidCut = byteBuffer.get(239);
map1.put("channel1CxMidCut", Byte.toUnsignedInt(channel1CxMidCut) + radarString);
/* 前端begin */
// 前端包头 2
short frontHeader = byteBuffer.getShort(240); // 6863 ---1acf
map1.put("frontHeader", Integer.toHexString((int) frontHeader));
// 前端序号 2
short heardBeforeNum = byteBuffer.getShort(242);
map1.put("heardBeforeNum", Short.toUnsignedInt(heardBeforeNum) + radarString);
// MARK地址 2
short markAddress = byteBuffer.getShort(244);
map1.put("markAddress", Short.toUnsignedInt(markAddress) + radarString);
// 通告方式 2
short style = byteBuffer.getShort(246);
map1.put("style", Short.toUnsignedInt(style) + radarString);
// 故障检测 1
byte faultDetection = byteBuffer.get(248);
map1.put("faultDetection", errorCheck(faultDetection));
// (雷达)本振锁定指示 1
byte locking = byteBuffer.get(249);
map1.put("locking", getLockingInfo(locking));
// 前端温度 2
short frontEndWorkTemperature2 = byteBuffer.getShort(250); // 30度
map1.put("frontEndWorkTemperature2", df2.format(frontEndWorkTemperature2 * 0.0078125));
// FPGA计数 1
byte fpga1 = byteBuffer.get(252);
map1.put("fpga1", Byte.toUnsignedInt(fpga1) + radarString);
// 指令状态 1
byte state1 = byteBuffer.get(253);
map1.put("state1", getCommondState(state1));
// 工作频率 2
short workPrence = byteBuffer.getShort(254);
map1.put("workPrence", Short.toUnsignedInt(workPrence) + radarString);
byteBuffer.position(256);
// 备份 12
byte[] backupss = new byte[12];
byteBuffer.get(backupss);
// 微波-CRC 2
short microwaveCRC = byteBuffer.getShort(268);
map1.put("microwaveCRC", Short.toUnsignedInt(microwaveCRC) + radarString);
// 前端包尾 2
short frontTail = byteBuffer.getShort(270);
map1.put("frontTail", Integer.toHexString(Short.toUnsignedInt(frontTail)));
// byteBuffer.position(272);
/* 前端end */
/* 关键状态begin */
// 通道1K7A生成PDW个数 4
// int a7k1=byteBuffer.getInt(272);
// map1.put("a7k1", Integer.toUnsignedString(a7k1));
// // 通道1K7A输出原始PDW个数 4
// int a7k1PDW=byteBuffer.getInt(276);
// // 分选K7接收原始PDW个数 4
// int a7DW=byteBuffer.getInt(280);
// // 分选K7排序后输出PDW个数 4
// int k7=byteBuffer.getInt(284);
// // 分选K7给DSP的PDW个数 4
// int k7DSP=byteBuffer.getInt(288);
// // 分选DSP接收的PDW个数 4
// int dsp=byteBuffer.getInt(292);
// // 分选DSP上传通道1的PDW个数 4
// int dspPDW=byteBuffer.getInt(296);
// // 分选K7上传通道1的PDW个数 4
// int k7pdw=byteBuffer.getInt(300);
// // 主控K7接收通道1上传的PDW个数 4
// int k7UpPdw=byteBuffer.getInt(304);
// // 主控DSP接收通道1的PDW个数 4
// int dspRecivePDW=byteBuffer.getInt(308);
// // 通道2 K7A生成PDW个数 4
// int createK7APDW=byteBuffer.getInt(312);
// // 通道2 K7A输出原始PDW个数 4
// int outPutK7APDW=byteBuffer.getInt(316);
// // 主控K7接收原始PDW个数 4
// int reciveK7APDW=byteBuffer.getInt(320);
// // 主控K7排序后输出PDW个数 4
// int masterControlK7PDW=byteBuffer.getInt(324);
// // 主控K7给DSP的PDW个数 4
// int masterControlK7SendPDW=byteBuffer.getInt(328);
// // 主控DSP接收的PDW个数 4
// int masterControlDSPRecivePDW=byteBuffer.getInt(332);
// // 主控DSP网络上传的PDW个数 4 //68 340
// int masterControlDSPUploadPDW=byteBuffer.getInt(336);
// // 通道1频谱状态</ 1
// byte frequencySpectrumState1=byteBuffer.get(340);
// // 通道2频谱状态 1
// byte frequencySpectrumState2=byteBuffer.get(341);
// byteBuffer.position(342);
// // 备份 2
// byte [] hingeState=new byte[2];
// // 分选dSP上传的辐射源个数 1
// byte sizingCountDSP=byteBuffer.get(346);
// // 分选K7辐射源状态 1
// byte sizingStateK7=byteBuffer.get(347);
// // 主控DSP上传辐射源个数 1
// byte masterControlDSPCount=byteBuffer.get(348);
// byteBuffer.position(349);
// // 备份 1
// byte [] hingeState2=new byte[1];
// // 分选发送的引导辐射源批号 1
// byte sizingSendNum=byteBuffer.get(350);
// // 通道1Z7_PL状态 1
// byte thoroughfareZ7PL=byteBuffer.get(351);
// // 通道1引导辐射源状态 1
// byte thoroughfareState=byteBuffer.get(352);
// // 通道1脉内引导辐射源带宽 1
// byte thoroughfareBrand=byteBuffer.get(353);
// // 通道1脉内引导辐射源批次号 1
// byte thoroughfareNum=byteBuffer.get(354);
// // 通道1脉内分析结果个数 1
// byte thoroughfareResultCount=byteBuffer.get(355);
// // 通道1脉间和信道化脉内类型 1
// byte thoroughfareInterpulseAndType=byteBuffer.get(356);
// // 通道1脉内类型 1
// byte thoroughfareType=byteBuffer.get(357);
// // 通道1脉内载频值 4
// int thoroughfareFrequency=byteBuffer.getInt(358);
// // 通道1脉内中心频率 4
// int thoroughfareAmong=byteBuffer.getInt(362);
// // 通道1脉内分析结果个数 1
// byte thoroughfareResultNum=byteBuffer.get(366);
// // 分选接收到的脉内信息1 366
// byte sizingReviceMessage=byteBuffer.get(367);
// byteBuffer.position(368);
// // 备份 3
// byte[] importendState = new byte[3];
// byteBuffer.get(importendState);
// //byteBuffer.position(369);
//
// // 主控发送的引导辐射源批号 1
// byte masterControlSendNUm=byteBuffer.get(371);
// // 通道2Z7_PL状态 1
// byte thoroughfareZ7PLTwo=byteBuffer.get(369);
// // 通道2引导辐射源状态 1
// byte thoroughfareStateTwo=byteBuffer.get(370);
// // 通道2脉内引导辐射源带宽 1
// byte thoroughfareBrandTwo=byteBuffer.get(371);
// // 通道2脉内引导辐射源批次号1
// byte thoroughfareNumTwo=byteBuffer.get(372);
// // 通道2脉内分析结果个数 1
// byte thoroughfareResultCountTwo=byteBuffer.get(373);
// // 通道2脉间和信道化脉内类型 1
// byte thoroughfareInterpulseAndTypeTwo=byteBuffer.get(374);
// // 通道2脉内类型 1
// byte thoroughfareTypeTwo=byteBuffer.get(375);
// // 通道2脉内载频值 4
// int thoroughfareFrequencyTwo=byteBuffer.getInt(376);
// // 通道2脉内中心频率</ 4
// int thoroughfareAmongTwo=byteBuffer.getInt(380);
// // 主控接收到的脉内信息 1
// byte masterControlReciveMessage=byteBuffer.get(384);
// byteBuffer.position(385);
// // 备份 3
// byte [] hingeState3=new byte[3];
// // 通道1K7心跳 1
// byte thoroughfareK7One=byteBuffer.get(388);
// // 通道1Z7心跳 1
// byte thoroughfareZ7One=byteBuffer.get(389);
// // 通道2K7心跳 1
// byte thoroughfareK7Two=byteBuffer.get(390);
// // 通道2Z7心跳 1
// byte thoroughfareZ7Two=byteBuffer.get(391);
// // 分选板心跳 1
// byte sizingHeartBeat=byteBuffer.get(392);
// // 主控板心跳 1
// byte masterControlHeartBeat=byteBuffer.get(393);
// byteBuffer.position(394);
// // 备份 6
// // (32字节)
// byte[] access = new byte[6];
// byteBuffer.get(access);
/* 电源状态 */
// 包头 2 CF1A 400是正确的
short electricSource = byteBuffer.getShort(400);
map1.put("electricSource", Integer.toHexString(Short.toUnsignedInt(electricSource)));
// +48V电压 2 voltage ,voltage ,plus minus
short voltagelPlus48 = byteBuffer.getShort(402);
map1.put("voltagelPlus48", getBoardTemp(voltagelPlus48));
// +48V电流 2
short anpeiPlus48 = byteBuffer.getShort(404);
map1.put("anpeiPlus48", getBoardTemp(anpeiPlus48));
// >+A12V(1)电压(计算机)</ 2
short voltagePlus12 = byteBuffer.getShort(406);
map1.put("voltagePlus12", getBoardTemp(voltagePlus12));
// +A12V(1)电流 2
short anpeiPlus12 = byteBuffer.getShort(408);
map1.put("anpeiPlus12", getBoardTemp(anpeiPlus12));
// +D12V电压 2
short d12V = byteBuffer.getShort(410);
map1.put("d12V", getBoardTemp(d12V));
// +D12V电流 2
short anpeiD12V = byteBuffer.getShort(412);
map1.put("anpeiD12V", getBoardTemp(anpeiD12V));
// >+A18V(1)电压 2
short votageA18V = byteBuffer.getShort(414);
map1.put("votageA18V", getBoardTemp(votageA18V));
// >+A18V(1)电流 2
short anpeiA18V = byteBuffer.getShort(416);
map1.put("anpeiA18V", getBoardTemp(anpeiA18V));
// +A18V(2)电压 2
short vatageA18V2 = byteBuffer.getShort(418);
map1.put("vatageA18V2", getBoardTemp(vatageA18V2));
// +A18V(2)电流 2
short anpeiA18V2 = byteBuffer.getShort(420);
map1.put("anpeiA18V2", getBoardTemp(anpeiA18V2));
// +A12V(2)电压(微波) 2
short vatageA12V2 = byteBuffer.getShort(422);
map1.put("vatageA12V2", getBoardTemp(vatageA12V2));
// +A12V(2)电流 2
short anpeiA12V2 = byteBuffer.getShort(424);
map1.put("anpeiA12V2", getBoardTemp(anpeiA12V2));
// >+D5V电压</ 2
short vategeD5V = byteBuffer.getShort(426);
map1.put("vategeD5V", getBoardTemp(vategeD5V));
// +D5V电流 2
short anpeiD5V = byteBuffer.getShort(428);
map1.put("anpeiD5V", getBoardTemp(anpeiD5V));
// >-5V电压 2
short vatageMinus5V = byteBuffer.getShort(430);
map1.put("vatageMinus5V", getBoardTemp(vatageMinus5V));
// -5V电流 2
short anpeiMinus5V = byteBuffer.getShort(432);
map1.put("anpeiMinus5V", getBoardTemp(anpeiMinus5V));
// +A6V电压 2
short vatagePlusA6V = byteBuffer.getShort(434);
map1.put("vatagePlusA6V", getBoardTemp(vatagePlusA6V));
// +A6V电流 2
short anpeiPlusA6V = byteBuffer.getShort(436);
map1.put("anpeiPlusA6V", getBoardTemp(anpeiPlusA6V));
// +24V电流 2
short anpeiPlus24V = byteBuffer.getShort(438);
map1.put("anpeiPlus24V", getBoardTemp(anpeiPlus24V));
// +24V电压 2
short vatagePlus24V = byteBuffer.getShort(440);
map1.put("vatagePlus24V", getBoardTemp(vatagePlus24V));
// 包尾 2 1DCF
short electricEnd = byteBuffer.getShort(442);
map1.put("electricEnd", Integer.toHexString(Short.toUnsignedInt(electricEnd)));
// (44)
// 结尾
int verify = byteBuffer.getInt(444); // 校验和
int messageEnd = byteBuffer.getInt(448); // 报文尾
map1.put("host", host);
simpMessagingTemplate.convertAndSend("/uploadRadarSubSystemWorkStatusMessage/send",
new ResultEntity(SystemStatusCodeEnum.SUCCESS, map1));
}
/**
* 敌我系统工作标签包
*/
@Async
public void uploadEnemyAndUsPackageMessage(ByteBuffer byteBuffer, String host) {
byteBuffer = byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
Map<String, Number> map = receiveFixedInformation(byteBuffer);
Map<String, String> map1 = new HashMap<>();
int messageLength = byteBuffer.getInt(48);
Long taskFlowNo = byteBuffer.getLong(52);
// 敌我系统状态信息
short header = byteBuffer.getShort(60); // 帧有效标记0x1ACF
short dataType = byteBuffer.getShort(62);// 数据类型
int dataLength = byteBuffer.getInt(64);// 数据长度
// byteBuffer.position(68);
/**
* 系统控制信息
*/
short hearderInformation = byteBuffer.getShort(68); // 包头 53F8
map1.put("hearderInformation", Integer.toHexString(Short.toUnsignedInt(hearderInformation)));
short systemControl = byteBuffer.getShort(70); // 信息包序号
map1.put("systemControl", Short.toUnsignedInt(systemControl) + radarString);
// TODO 时间码
long timeCodings = byteBuffer.getLong(72);
String timeString = longToBinaryString(timeCodings);
String resultString = "";
// 年
resultString = resultString + String.valueOf(Short.parseShort(timeString.substring(0, 16), 2)) + "/";
// 月
resultString = resultString + String.valueOf(Short.parseShort(timeString.substring(16, 24), 2)) + "/";
// 日
resultString = resultString + String.valueOf(Short.parseShort(timeString.substring(24, 32), 2)) + " ";
// 时
resultString = resultString + String.valueOf(Short.parseShort(timeString.substring(56, 64), 2)) + ":";
// 分
resultString = resultString + String.valueOf(Short.parseShort(timeString.substring(48, 56), 2)) + ":";
// 秒
resultString = resultString + String.valueOf(Short.parseShort(timeString.substring(32, 48), 2));
map1.put("timeCodings", resultString);
byteBuffer.position(80);
byte[] byte1 = new byte[52]; // 备份
byteBuffer.get(byte1);
/**
* GPS数据
*/
int hearderGPS = byteBuffer.getInt(132); // GPS包头 01728d33
map1.put("hearderGPS", Integer.toHexString(hearderGPS));
byte hour = byteBuffer.get(136); // 时
map1.put("hour", Byte.toUnsignedInt(hour) + radarString);
byte mini = byteBuffer.get(137); // 分
map1.put("mini", Byte.toUnsignedInt(mini) + radarString);
short second = byteBuffer.getShort(138); // 秒
map1.put("second", Short.toUnsignedInt(second) + radarString);
byte days = byteBuffer.get(140); // 日
map1.put("days", Byte.toUnsignedInt(days) + radarString);
byte mouths = byteBuffer.get(141); // 月
map1.put("mouths", Byte.toUnsignedInt(mouths) + radarString);
short year = byteBuffer.getShort(142); // 年
map1.put("year", Short.toUnsignedInt(year) + radarString);
float longitude = byteBuffer.getFloat(144); // 经度(保留小数点后4位)
// 解析
map1.put("longitude", String.valueOf(jd.format(longitude)));
float latitude = byteBuffer.getFloat(148); // 纬度
map1.put("latitude", String.valueOf(jd.format(latitude)));
int height = byteBuffer.getInt(152); // 高度
map1.put("height", String.valueOf(jd.format(height)));
byte referenceSource = byteBuffer.get(156); // 参考源
map1.put("referenceSource", Byte.toUnsignedInt(referenceSource) + radarString);
byte synchronizationState = byteBuffer.get(157); // 同步状态
map1.put("synchronizationState", Byte.toUnsignedInt(synchronizationState) + radarString);
byte outState = byteBuffer.get(158); // 输出状态
map1.put("outState", Byte.toUnsignedInt(outState) + radarString);
byte hourChoose = byteBuffer.get(159); // 时区选择
map1.put("hourChoose", Byte.toUnsignedInt(hourChoose) + radarString);
int synchronizationAccuracy = byteBuffer.getInt(160); // 同步精度
map1.put("synchronizationAccuracy", Integer.toUnsignedString(synchronizationAccuracy));
byte latitudeTips = byteBuffer.get(164); // 纬度提示
map1.put("latitudeTips", Byte.toUnsignedInt(latitudeTips) + radarString);
byte longitudeTips = byteBuffer.get(165); // 经度提示
map1.put("longitudeTips", Byte.toUnsignedInt(longitudeTips) + radarString);
byte validationTotal = byteBuffer.get(166); // 校验和
map1.put("validationTotal", Byte.toUnsignedInt(validationTotal) + radarString);
byteBuffer.position(167);
byte[] backupsGPS = new byte[29]; // GPS数据备份
byteBuffer.get(backupsGPS);
// 敌我系统状态
// 数据信息
byte systemWorkState = byteBuffer.get(196);// 系统工作状态
map1.put("systemWorkState", getSystemWorkState(systemWorkState));
byte receiveInstruction = byteBuffer.get(197); // 接收指令计数
map1.put("receiveInstruction", Byte.toUnsignedInt(receiveInstruction) + radarString);
++receiveInstruction;
/** 分机计数begin */
byte extensionCount = byteBuffer.get(198);
map1.put("extensionCount", getZhuKongJiShuNum1(extensionCount));
/** 解析分机计数end */
/** 分机计数begin */
byte extensionCount1 = byteBuffer.get(199);
map1.put("extensionCount1", getZhuKongJiShuNum2(extensionCount1));
/** 分机计数end */
byteBuffer.position(200);
byte[] byte2 = new byte[4]; // 备份
byteBuffer.get(byte2);
short frontEndOperatingTemperature = byteBuffer.getShort(204); // 前端工作温度
map1.put("frontEndOperatingTemperature",
df2.format(Short.toUnsignedInt(frontEndOperatingTemperature) * 0.0078125));
short mainControlWorkingTemperature = byteBuffer.getShort(206); // 主控工作温度
map1.put("mainControlWorkingTemperature",
df2.format(Short.toUnsignedInt(mainControlWorkingTemperature) * 0.01));
short detectionOfWorkingTemperature = byteBuffer.getShort(208); // 检测工作温度
map1.put("detectionOfWorkingTemperature",
df2.format(Short.toUnsignedInt(detectionOfWorkingTemperature) * 0.01));
byteBuffer.position(210);
byte[] bytes3 = new byte[10]; // 备份(10)
byteBuffer.get(bytes3);
int numberOfFullPulse740 = byteBuffer.getInt(220);// 740全脉冲个数
map1.put("numberOfFullPulse740", Integer.toUnsignedString(numberOfFullPulse740));
int numberOfFullPulse837_5 = byteBuffer.getInt(224);// 837.5全脉冲个数(两个8字节)
map1.put("numberOfFullPulse837_5", Integer.toUnsignedString(numberOfFullPulse837_5));
int PDW1030 = byteBuffer.getInt(228);// 1030PDW个数（4）
map1.put("PDW1030", Integer.toUnsignedString(PDW1030));
int PDW1059 = byteBuffer.getInt(232);// 1059PDW个数（4）
map1.put("PDW1059", Integer.toUnsignedString(PDW1059));
int PDW1090 = byteBuffer.getInt(236);// 1090PDW个数（4）
map1.put("PDW1090", Integer.toUnsignedString(PDW1090));
int PWD1464 = byteBuffer.getInt(240);// 1464PDW个数（4）
map1.put("PWD1464", Integer.toUnsignedString(PWD1464));
int PWD1532 = byteBuffer.getInt(244);// 1532PDW个数（4）
map1.put("PWD1532", Integer.toUnsignedString(PWD1532));
long enemyAndUs740 = byteBuffer.getInt(248);// 740IFF识别个数(8)
map1.put("enemyAndUs740", Long.toUnsignedString(enemyAndUs740));
int enemyAndUs1030 = byteBuffer.getInt(256);// 1030IFF识别个数（4）
map1.put("enemyAndUs1030", Integer.toUnsignedString(enemyAndUs1030));
int IFF1090 = byteBuffer.getInt(260); // 1090IFF个数（4）
map1.put("IFF1090", Integer.toUnsignedString(IFF1090));
int IFF1464 = byteBuffer.getInt(264);// 1464IFF个数（4）
map1.put("IFF1464", Integer.toUnsignedString(IFF1464));
int IFF1532 = byteBuffer.getInt(268);// 1532IFF个数（4）
map1.put("IFF1532", Integer.toUnsignedString(IFF1532));
byteBuffer.position(272);
byte[] mid1030 = new byte[28];// 1030中频个数（28）
byteBuffer.get(mid1030);
int M51030 = byteBuffer.getInt(300);// 1030 M5个数（4）
map1.put("M51030", Integer.toUnsignedString(M51030));
int M51090 = byteBuffer.getInt(304);// 1090 M5个数（4）
map1.put("M51090", Integer.toUnsignedString(M51090));
long midM51030 = byteBuffer.getLong(308);// 1030 M5中频个数（8）
map1.put("midM51030", Long.toUnsignedString(midM51030));
byteBuffer.position(316);
byte[] bytes4 = new byte[154]; // 电源状态(154)
byteBuffer.get(bytes4);
byte masterControlFPGA1 = byteBuffer.get(470); // 主控FPGA1版本号（1）
map1.put("masterControlFPGA1", df2.format(Byte.toUnsignedInt(masterControlFPGA1) * 0.01));
byte masterControlFPGA2S = byteBuffer.get(471);// 主控FPGA2版本号（1）
map1.put("masterControlFPGA2S", df2.format(Byte.toUnsignedInt(masterControlFPGA2S) * 0.01));
byte masterControlDSP = byteBuffer.get(472); // 主控DSP版本号（1）
Integer masterDsp = getDsp(masterControlDSP);
map1.put("masterControlDSP", String.valueOf(df2.format(masterDsp * 0.01)));
byte testingFPGA1 = byteBuffer.get(473);// 检测FPGA1版本号（1）
Integer testing = getDsp(testingFPGA1);
map1.put("testingFPGA1", String.valueOf(df2.format(testing * 0.01)));
byte testingFPGA2 = byteBuffer.get(474);// 检测FPGA2版本号（1）
Integer testingF2 = getDsp(testingFPGA2);
map1.put("testingFPGA2", String.valueOf(df2.format(testingF2 * 0.01)));
byte testingDSP = byteBuffer.get(475);// 检测DSP版本号（1）
Integer test2 = getDsp(testingDSP);
map1.put("testingDSP", String.valueOf(df2.format(test2 * 0.01)));
byteBuffer.position(476);
byte[] bytes5 = new byte[16]; // 版本号（16）
byteBuffer.get(bytes5);
String masterControlIp = getToIp(byteBuffer.getInt(492));// 主控IP地址（4）
map1.put("masterControlIp", masterControlIp);
String testingIp = getToIp(byteBuffer.getInt(496)); // 检测IP地址（4）
map1.put("testingIp", testingIp);
String dataTransmissionIp2 = getToIp(byteBuffer.getInt(500));// 数传2 IP地址（4）
map1.put("dataTransmissionIp2", dataTransmissionIp2);
String dataTransmissionIp3 = getToIp(byteBuffer.getInt(504));// 数传3 IP地址3（4）
map1.put("dataTransmissionIp3", dataTransmissionIp3);
short masterDSP = byteBuffer.getShort(508);// 主控DSP端口号（2）
map1.put("masterDSP", Short.toUnsignedInt(masterDSP) + radarString);
short internalInstructionSide = byteBuffer.getShort(510);// 内部指令端口号（2）
map1.put("internalInstructionSide", Short.toUnsignedInt(internalInstructionSide) + radarString);
byteBuffer.position(512);
byte[] bytes6 = new byte[4]; // 备份（4）
byteBuffer.get(bytes6);
// 主控MAC地址
String masterControlMAC = getMac(byteBuffer.getShort(516), byteBuffer.getInt(518));
map1.put("masterControlMAC", masterControlMAC);
// 检测MAC地址（6）
String testingMAC = getMac(byteBuffer.getShort(522), byteBuffer.getInt(524));
map1.put("testingMAC", testingMAC);
// 数传2 MAC地址（6）
String dataTransmissionMAC2 = getMac(byteBuffer.getShort(528), byteBuffer.getInt(530));
map1.put("dataTransmissionMAC2", dataTransmissionMAC2);
// 数传3MAC地址（6）
String dataTransmissionMAC3 = getMac(byteBuffer.getShort(534), byteBuffer.getInt(536));
map1.put("dataTransmissionMAC3", dataTransmissionMAC3);
byteBuffer.position(540);
byte[] bytes7 = new byte[16]; // 备份(16)
byteBuffer.get(bytes7);
String masterComputerIp = getToIp(byteBuffer.getInt(556)); // 主控上位机IP（4）
map1.put("masterComputerIp", masterComputerIp);
String dataTransmissionIP1 = getToIp(byteBuffer.getInt(560)); // 数传1上位机IP（4）
map1.put("dataTransmissionIP1", dataTransmissionIP1);
String dataTransmissionIP2 = getToIp(byteBuffer.getInt(564)); // 数传2上位机IP（4）
map1.put("dataTransmissionIP2", dataTransmissionIP2);
String dataTransmissionIP3 = getToIp(byteBuffer.getInt(568));// 数传3上位机IP（4）
map1.put("dataTransmissionIP3", dataTransmissionIP3);
short labelPackage = byteBuffer.getShort(572);// 标签包端口号（2）
map1.put("labelPackage", Short.toUnsignedInt(labelPackage) + radarString);
short dataPort1 = byteBuffer.getShort(574); // 数据端口号1（2）
map1.put("dataPort1", Short.toUnsignedInt(dataPort1) + radarString);
short dataPort2 = byteBuffer.getShort(576); // 数据端口号2（2）
map1.put("dataPort2", Short.toUnsignedInt(dataPort2) + radarString);
short dataPort3 = byteBuffer.getShort(578);// 数据端口号3（2）
map1.put("dataPort3", Short.toUnsignedInt(dataPort3) + radarString);
String internalStateIP = getToIp(byteBuffer.getInt(580));// 内部状态IP（4）
map1.put("internalStateIP", internalStateIP);
short internalStatePort = byteBuffer.getShort(584);// 内部状态端口号（2）
map1.put("internalStatePort", Short.toUnsignedInt(internalStatePort) + radarString);
byteBuffer.position(586);
byte[] bytes11 = new byte[2];// 备份(2)
byteBuffer.get(bytes11);
/*
* byteBuffer.position(557); byte [] frontEndState=new byte[32];
* byteBuffer.get(frontEndState);
*/
/**
* 前端状态
*/
short anteriorSegmentHearder = byteBuffer.getShort(588); // 前端包头（不显示）(2)/1ACF
// map1.put("anteriorSegmentHearder",
// Short.toUnsignedInt(anteriorSegmentHearder) + radarString);
String hexString = Integer.toHexString(Short.toUnsignedInt(anteriorSegmentHearder));
map1.put("anteriorSegmentHearder", hexString);
short anteriorSegmentNum = byteBuffer.getShort(590); // 前端序号（不显示）(2)
map1.put("anteriorSegmentNum", Short.toUnsignedInt(anteriorSegmentNum) + radarString);
short addressMARK = byteBuffer.getShort(592); // MARK地址（不显示）(2)
map1.put("addressMARK", Short.toUnsignedInt(addressMARK) + radarString);
short noticeStyle = byteBuffer.getShort(594); // 通知方式（不显示）(2)
map1.put("noticeStyle", Short.toUnsignedInt(noticeStyle) + radarString);
// 频点1,2故障检测(1)
byte frequencyPointFault1_2 = byteBuffer.get(596);
StringBuilder stringBuilder1_2 = getByte(frequencyPointFault1_2);
map1.put("frequencyPointFault1_2", String.valueOf(stringBuilder1_2));
// 频点3,4故障检测输出(1)
byte frequencyPointFault3_4 = byteBuffer.get(597);
map1.put("frequencyPointFault3_4", String.valueOf(frequencyPointFault3_4));
// 频点5,6故障检测(1)
byte frequencyPointFault5_6 = byteBuffer.get(598);
StringBuilder stringBuilder5_6_1 = getByte(frequencyPointFault5_6);
map1.put("frequencyPointFault5_6", String.valueOf(stringBuilder5_6_1));
// 频点7,8故障检测(1)
byte frequencyPointFault7_8 = byteBuffer.get(599);
StringBuilder stringBuilder7_8_1 = getByte(frequencyPointFault7_8);
map1.put("frequencyPointFault7_8", String.valueOf(stringBuilder7_8_1));
// 采样时钟(1)
byte samplingClock = byteBuffer.get(600);
map1.put("samplingClock", getSamplingClock(samplingClock));
// 本帧锁定指示
byte locking = byteBuffer.get(601);
StringBuilder frameLocking2_1 = getByte(locking);
map1.put("locking", String.valueOf(frameLocking2_1));
// 自检源锁定指示(1)
byte selfLocking = byteBuffer.get(602);
map1.put("selfLocking", Byte.toUnsignedInt(selfLocking) + radarString);
// 微波模块工作温度(2)
short workingTemp = byteBuffer.getShort(603);
map1.put("workingTemp", df2.format(Short.toUnsignedLong(workingTemp) * 0.0078125));
// FPGA计数(1)
byte beforNumFPGA = byteBuffer.get(605);
map1.put("beforNumFPGA", Byte.toUnsignedInt(beforNumFPGA) + radarString);
// 自检源频点选择(1)
byte selfPointChoose = byteBuffer.get(606);
map1.put("selfPointChoose", Byte.toUnsignedInt(selfPointChoose) + radarString);
// 敌我前端工作模式(1)
byte beforEnemyAndUsWork = byteBuffer.get(607);
map1.put("beforEnemyAndUsWork", Byte.toUnsignedInt(beforEnemyAndUsWork) + radarString);
byteBuffer.position(608);
byte[] beforByte = new byte[8]; // 备份(8)
byteBuffer.get(beforByte);
// 前端crc
short crc = byteBuffer.getShort(616);
// 包尾
short tail = byteBuffer.getShort(618);
map1.put("tail", Integer.toHexString(Short.toUnsignedInt(tail)));
/**
* 关键状态信息(敌我关键状态)begin
*/
byte numFPGA1 = byteBuffer.get(620);// FPGA1计数(1)
map1.put("numFPGA1", Byte.toUnsignedInt(numFPGA1) + "");
short numFPGA1Brodcast = byteBuffer.getShort(621);// FPGA1广播计数(1)
map1.put("numFPGA1Brodcast", Short.toUnsignedInt(numFPGA1Brodcast) + "");
byte clockFPGA1State = byteBuffer.get(623);// FPGA1时钟状态(1)
map1.put("clockFPGA1State", Byte.toUnsignedInt(clockFPGA1State) + "");
short numFPGA1AD = byteBuffer.getShort(624);// FPGA1 AD量化值(2)
map1.put("numFPGA1AD", Short.toUnsignedInt(numFPGA1AD) + "");
int num1030PDW = byteBuffer.getInt(626);// 1030PDW个数(4)
map1.put("num1030PDW", Integer.toUnsignedString(num1030PDW) + "");
int num1030M5PWD = byteBuffer.getInt(630);// 1030M5 PWD个数(4)
map1.put("num1030M5PWD", Integer.toUnsignedString(num1030M5PWD) + "");
short num1030IFF = byteBuffer.getShort(634);// 1030IFF个数(2)
map1.put("num1030IFF", Short.toUnsignedInt(num1030IFF) + "");
short num1030M5IFF = byteBuffer.getShort(636);// 1030M5 IFF个数(2)
map1.put("num1030M5IFF", Short.toUnsignedInt(num1030M5IFF) + ""); // (18)
byte numFPGA2 = byteBuffer.get(638);// FPGA2个数
map1.put("numFPGA2", Byte.toUnsignedInt(numFPGA2) + "");
short numFPGA2Brodcast = byteBuffer.getShort(639);// FPGA2广播计数
map1.put("numFPGA2Brodcast", Short.toUnsignedInt(numFPGA2Brodcast) + radarString);
byte clockFPGA2State = byteBuffer.get(641);// FPGA2时钟状态
map1.put("clockFPGA2State", Byte.toUnsignedInt(clockFPGA2State) + radarString);
short numpFPGA2AD = byteBuffer.getShort(642);// FPGA2 AD量化值
map1.put("numpFPGA2AD", Short.toUnsignedInt(numpFPGA2AD) + radarString);
int num1090 = byteBuffer.getInt(644);// 1090PDW个数
map1.put("num1090", Integer.toUnsignedString(num1090));
int num1090M5PDW = byteBuffer.getInt(648);// 1090M5PDW个数
map1.put("num1090M5PDW", Integer.toUnsignedString(num1090M5PDW));
short num1090IFF = byteBuffer.getShort(652);// 1090IFF个数
map1.put("num1090IFF", Short.toUnsignedInt(num1090IFF) + radarString);
short num1090M5IFF = byteBuffer.getShort(654);// 1090M5 IFF个数
map1.put("num1090M5IFF", Short.toUnsignedInt(num1090M5IFF) + radarString); // （18）
short informationDSPNum = byteBuffer.getShort(656);// DSP信息包序号
map1.put("informationDSPNum", Short.toUnsignedInt(informationDSPNum) + radarString);
short cardWorkingTem = byteBuffer.getShort(658);// 卡板工作温度
map1.put("cardWorkingTem", Short.toUnsignedInt(cardWorkingTem) + radarString);
int numDSP1030 = byteBuffer.getInt(660);// DSP 1030全脉冲个数
map1.put("numDSP1030", Integer.toUnsignedString(numDSP1030));
int numDSP1090 = byteBuffer.getInt(664);// 1DSP 1090全脉冲个数
map1.put("numDSP1090", Integer.toUnsignedString(numDSP1090));
int numEnemyAndUs1030 = byteBuffer.getInt(668);// DSP 1030敌我个数
map1.put("numEnemyAndUs1030", Integer.toUnsignedString(numEnemyAndUs1030));
int numEnemyAndUs1090 = byteBuffer.getInt(672);// DSP 1090敌我个数
map1.put("numEnemyAndUs1090", Integer.toUnsignedString(numEnemyAndUs1090));
int numEnemyAndUsM51030 = byteBuffer.getInt(676);// DSP 1030M5敌我个数
map1.put("numEnemyAndUsM51030", Integer.toUnsignedString(numEnemyAndUsM51030));
int numEnemyAndUsM51090 = byteBuffer.getInt(680);// DSP1090M5个数
map1.put("numEnemyAndUsM51090", Integer.toUnsignedString(numEnemyAndUsM51090)); // （28）
// 检测板
byte numTestFPGA1 = byteBuffer.get(684);// FPGA1计数
map1.put("numTestFPGA1", Byte.toUnsignedInt(numTestFPGA1) + "");
short brodcastTestFPGA1 = byteBuffer.getShort(685);// FPGA1广播计数
map1.put("brodcastTestFPGA1", Short.toUnsignedInt(brodcastTestFPGA1) + radarString);
byte numTestFPGA2 = byteBuffer.get(687);// FPGA2个数
map1.put("numTestFPGA2", Byte.toUnsignedInt(numTestFPGA2) + "");
short numtTestBrodcastFPGA2 = byteBuffer.getShort(688);// FPGA2广播计数
map1.put("numtTestBrodcastFPGA2", Short.toUnsignedInt(numtTestBrodcastFPGA2) + radarString);
byte clockTestStateFPGA2 = byteBuffer.get(690);// FPGA2时钟状态
map1.put("clockTestStateFPGA2", Byte.toUnsignedInt(clockTestStateFPGA2) + radarString);
short clockTestStateFPGAD = byteBuffer.getShort(691);// FPGA2 AD量化值
map1.put("clockTestStateFPGAD", Short.toUnsignedInt(clockTestStateFPGAD) + radarString);
int num1464 = byteBuffer.getInt(693);// 1464PDW个数
map1.put("num1464", Integer.toUnsignedString(num1464));
int num1532 = byteBuffer.getInt(697);// 1532PDW个数
map1.put("num1532", Integer.toUnsignedString(num1532));
short num1464IFF = byteBuffer.getShort(701);// 1464IFF个数
map1.put("num1464IFF", Short.toUnsignedInt(num1464IFF) + radarString);
short num1532IFF = byteBuffer.getShort(703);// 1532 IFF个数
map1.put("num1532IFF", Short.toUnsignedInt(num1532IFF) + radarString); // （18）
// 检测板
byte numDSP = byteBuffer.get(705);// DSP计数
map1.put("numDSP", Byte.toUnsignedInt(numDSP) + "");
short informationPacageDSP = byteBuffer.getShort(706);// DSP信息包序号
map1.put("informationPacageDSP", Short.toUnsignedInt(informationPacageDSP) + radarString);
short cardWorkingTemp = byteBuffer.getShort(708);// 卡板工作温度
map1.put("cardWorkingTemp", getBoardTemp(cardWorkingTemp));
int num1464DSP = byteBuffer.getInt(710);// DSP1464全脉冲个数
map1.put("num1464DSP", Integer.toUnsignedString(num1464DSP));
int num1532DSP = byteBuffer.getInt(714);// DSP1532全脉冲个数
map1.put("num1532DSP", Integer.toUnsignedString(num1532DSP));
int num1464EnemyAndUsDSP = byteBuffer.getInt(718);// DSP 1464敌我个数
map1.put("num1464EnemyAndUsDSP", Integer.toUnsignedString(num1464EnemyAndUsDSP));
int num1532EnemyAndUsDSP = byteBuffer.getInt(722);// DSP 1532敌我个数
map1.put("num1532EnemyAndUsDSP", Integer.toUnsignedString(num1532EnemyAndUsDSP)); // （21）
byteBuffer.position(726);
// =======================
/* 关键状态end */
byte[] chooseMCU = new byte[6];// MCU加载选择
byteBuffer.get(chooseMCU);
byteBuffer.position(732);
byte[] restructureState = new byte[6]; // 重构状态
byteBuffer.get(restructureState);
short restructureNum = byteBuffer.getShort(738); // 重构发送包数
map1.put("restructureNum", String.valueOf(restructureNum));
short restructureTotal = byteBuffer.getShort(740);// 重构发送统计
map1.put("restructureTotal", String.valueOf(restructureTotal));
byteBuffer.position(742);
byte[] bytes12 = new byte[64]; // 备份
byteBuffer.get(bytes12);
int end = byteBuffer.getInt(806); // 包尾
// 结尾
int verify = byteBuffer.getInt(810); // 校验和
int messageEnd = byteBuffer.getInt(814); // 报文尾
map1.put("host", host);
simpMessagingTemplate.convertAndSend("/uploadEnemyAndUsPackageMessage/send",
new ResultEntity(SystemStatusCodeEnum.SUCCESS, map1));
}
// 解析系统控制信息
private SystemControlBroadcastCMD systemControlBroadcastCMDs(byte[] bytes) {
SystemControlBroadcastCMD systemControlBroadcastCMD = new SystemControlBroadcastCMD();
ByteBuffer byteBuffer = ByteBuffer.allocate(64);
byteBuffer.put(bytes);
short header = byteBuffer.getShort();
systemControlBroadcastCMD.setMessagePackageNum(byteBuffer.getShort(3));
byte[] bytes1 = new byte[8];
byteBuffer.get(bytes1, 5, 8);
String time = new String(bytes1);
systemControlBroadcastCMD.setTimeCode(time);
systemControlBroadcastCMD.setWorkWay(byteBuffer.get(13));
systemControlBroadcastCMD.setBandwidthChoose(byteBuffer.get(14));
systemControlBroadcastCMD.setWorkCycleNum(byteBuffer.get(15));
systemControlBroadcastCMD.setWorkCycleLength(byteBuffer.get(16));
systemControlBroadcastCMD.setCenterFrequency(byteBuffer.getShort(17));
systemControlBroadcastCMD.setDirectionFindingAntennaChoose(byteBuffer.get(19));
systemControlBroadcastCMD.setScoutAntennaChoose(byteBuffer.get(20));
systemControlBroadcastCMD.setPulseScreenMinimumFrequency(byteBuffer.get(27));
systemControlBroadcastCMD.setPulseScreenMaximumFrequency(byteBuffer.getShort(29));
systemControlBroadcastCMD.setPulseScreenMinimumRange(byteBuffer.get(31));
systemControlBroadcastCMD.setPulseScreenMaximumRange(byteBuffer.get(32));
systemControlBroadcastCMD.setPulseScreenMinimumPulseWidth(byteBuffer.getShort(33));
systemControlBroadcastCMD.setPulseScreenMaximumPulseWidth(byteBuffer.getShort(35));
byte[] bytes2 = new byte[16];
byteBuffer.get(bytes2, 37, 16);
systemControlBroadcastCMD.setRouteShield(bytes2);
systemControlBroadcastCMD.setWithinThePulseGuidanceSwitch(byteBuffer.get(53));
systemControlBroadcastCMD.setWithinThePulseGuidance(byteBuffer.get(54));
systemControlBroadcastCMD.setUploadFullPulseNum(byteBuffer.getShort(55));
byte[] bytes3 = new byte[2];
byteBuffer.get(bytes3, 57, 2);
StringBuilder stringBuilder = new StringBuilder();
for (byte b : bytes3) {
String tString = Integer.toBinaryString((b & 0xFF) + 0x100).substring(1);
stringBuilder.append(tString);
}
systemControlBroadcastCMD.setExtensionControl(stringBuilder.toString());
String tString = Integer.toBinaryString((byteBuffer.get(59) & 0xFF) + 0x100).substring(1);
systemControlBroadcastCMD.setEquipmentSerialNum(tString);
systemControlBroadcastCMD.setDetectionThresholdAdjustment(byteBuffer.get(60));
return systemControlBroadcastCMD;
}
// 查询该IP是否存在
private boolean hasHostIP(String host) {
Optional<AllHost> allHost = hostRepository.findByHost(host);
return allHost.isPresent();
}
public List<AllHost> findAll() {
return hostRepository.findAll();
}
// 解析mac
private static String getMac(short s, int c) {
String g;
String d = Integer.toHexString(s);
// 当short s为负数时 如：-10000 转换成16进制后为 FFFFD8F0 因为前4位没用，所以需要截取后4位。正数时则不需要
if (s < 0) {
g = d.substring(4);
// 如果 s为0时，需要补齐零
} else if (s == 0) {
g = d + "000";
} else {
g = d;
}
String f = Integer.toHexString(c);
if (c == 0) {
f = f + "0000000";
}
String h = f + g;
// 需要转换成大写形式显示给前端方便显示
StringBuilder stringBuilder = new StringBuilder(h.toUpperCase());
// 补上冒号 直接传给前端
stringBuilder.insert(2, " - ");
stringBuilder.insert(7, " - ");
stringBuilder.insert(12, " - ");
stringBuilder.insert(17, " - ");
stringBuilder.insert(22, " - ");
return stringBuilder.toString();
}
// 解析IP地址
private static String getIP(byte[] bytes) {
StringBuilder stringBuilder = new StringBuilder();
// 为什么要从大到小 循环
// 因为 192.168.31.88 这样类似的ip byte[3] 是192 所以要先从大到小循环
for (int i = bytes.length - 1; i >= 0; i--) {
/**
*
* 如果当前值小于0，即为负数 那么需要将当前值转换成16进制，再转成10进制 解释： 为什么会为负数？ 答：
* 因为当传过来的数大于127时，那么转成byte时会转换成负数 如168 --> 会变成 -88
* 这个时候就需要将-88先转换成16进制，再转换成String类型 转回168
*/
if (bytes[i] < 0) {
/**
* 因为由后端拼接IP所以 当遍历到最后一个字节时 不需要再加小数点 所以要做判断
*/
if (i == 0) {
stringBuilder.append(new BigInteger(Integer.toHexString(bytes[i]).substring(6), 16).toString());
} else {
stringBuilder.append(new BigInteger(Integer.toHexString(bytes[i]).substring(6), 16).toString())
.append(".");
}
} else {
if (i == 0) {
stringBuilder.append(bytes[i]);
} else {
// 当为正数时 不需要判断 直接在末尾加小数点
stringBuilder.append(bytes[i]).append(".");
}
}
}
return stringBuilder.toString();
}
// ip解析
// 获取到10进制的ip转换成127.0.0.1形式
public static String getToIp(int ip) {
StringBuffer sb = new StringBuffer("");
sb.append(ip & 0xFF);
sb.append(".");
sb.append(ip >> 8 & 0xFF);
sb.append(".");
sb.append(ip >> 16 & 0xFF);
sb.append(".");
sb.append(ip >> 24 & 0xFF);
return sb.toString();
}
// 二进制转换成10进制
public static int BinaryToDecimal(int binaryNumber) {
int decimal = 0;
int p = 0;
while (true) {
if (binaryNumber == 0) {
break;
} else {
int temp = binaryNumber % 10;
decimal += temp * Math.pow(2, p);
binaryNumber = binaryNumber / 10;
p++;
}
}
return decimal;
}
// 解析主控DSP版本号
private static Integer getDsp(byte dsp) {
String dsString = Integer.toBinaryString((dsp & 0xFF) + 0x100).substring(1);
BigInteger bigInteger = new BigInteger(dsString, 2);
Integer ds = Integer.parseInt(bigInteger.toString());
return ds;
}
// 截取单个bit（short类型）
public static StringBuilder getShort(short shorts) {
String radar = Integer.toBinaryString(shorts);
StringBuilder stringBuilder4 = new StringBuilder();
int a1 = 8 - radar.length();
String bString1 = "0";
for (int i = 0; i < a1; i++) {
// stringBuilder3.append(b);
radar = bString1 + radar;
}
StringBuilder stringBuilder2 = new StringBuilder(radar);
stringBuilder2.reverse();
// 每两位转10进制数值int输出
for (int i = 2; i < 8; i += 1) {
String rstr = stringBuilder2.substring(i, i + 1);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
stringBuilder4.append(ss);
}
return stringBuilder4;
}
// 获取单个bit值
public static StringBuilder getByte(byte a) {
String po = Integer.toBinaryString((a & 0xFF) + 0x100).substring(1);
StringBuilder stringBuilderdsp = new StringBuilder();
int a2 = 8 - po.length();
String bString2 = "0";
for (int i = 0; i < a2; i++) {
po = bString2 + po;
}
StringBuilder stringBuilder = new StringBuilder(po);
stringBuilder.reverse();
for (int i = 0; i < 8; i += 1) {
String rstr = stringBuilder.substring(i, i + 1);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
stringBuilderdsp.append(ss);
}
return stringBuilderdsp;
}
// 指令状态解析
public String getCommondState(byte b) {
String binaryString = getBinaryString(b);
String temp = new StringBuilder(binaryString).reverse().substring(0, 4) + binaryString.substring(0, 4);
String result = "";
result = result + temp.substring(0, 1);
result = result + temp.substring(1, 2);
result = result + temp.substring(2, 3);
result = result + temp.substring(3, 4);
result = result + Integer.parseUnsignedInt(temp.substring(4, 8), 2);
return result;
}
// 截取两个bit值解析（8字节）
// 获取两个bit值
public static StringBuilder getDouble(byte doubles) {
String masterControl1 = Integer.toBinaryString(doubles);
StringBuilder stringBuilder4 = new StringBuilder();
int a1 = 8 - masterControl1.length();
String bString1 = "0";
for (int i = 0; i < a1; i++) {
// stringBuilder3.append(b);
masterControl1 = bString1 + masterControl1;
}
StringBuilder stringBuilder2 = new StringBuilder(masterControl1);
stringBuilder2.reverse();
// 每两位转10进制数值int输出
for (int i = 2; i < 8; i += 2) {
String rstr = stringBuilder2.substring(i, i + 2);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
stringBuilder4.append(ss);
}
return stringBuilder4;
}
// 解析分机状态
public static String getFenjiState(short control) {
String resultString = "";
String binaryString = Integer.toBinaryString(Short.toUnsignedInt(control));
int leftNum = 16 - binaryString.length();
for (int i = 0; i < leftNum; i++) {
binaryString = "0" + binaryString;
}
resultString = resultString + binaryString.substring(binaryString.length() - 1);
resultString = resultString + Integer.parseInt(binaryString.substring(3, 5), 2);
return resultString;
}
// 解析工作状态分机控制
public static String getFenjiControl(short control) {
String resultString = "";
String binaryString = Integer.toBinaryString(Short.toUnsignedInt(control));
int leftNum = 16 - binaryString.length();
for (int i = 0; i < leftNum; i++) {
binaryString = "0" + binaryString;
}
resultString = resultString + binaryString.substring(15);
resultString = resultString + binaryString.substring(14, 15);
return resultString;
}
// 解析卡板工作温度
public static String getCardTemp(short cardTemp) {
String temp = Integer.toBinaryString((cardTemp & 0xFF) + 0x100).substring(1);
String worktemp = "";
int a1 = 32 - temp.length();
String bString1 = "0";
for (int i = 0; i < a1; i++) {
// stringBuilder3.append(b);
temp = bString1 + temp;
}
// 每两位转10进制数值int输出
for (int i = 0; i < 8; i += 4) {
String rstr = temp.substring(i, i + 4);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
worktemp = worktemp + "." + ss;
}
return worktemp;
}
// 序号解析(32位)
public static int getNum(short num) {
String masterControl1 = Integer.toBinaryString((num & 0xFF) + 0x100).substring(1);
int a1 = 16 - masterControl1.length();
String bString1 = "0";
for (int i = 0; i < a1; i++) {
masterControl1 = bString1 + masterControl1;
}
StringBuilder stringBuilder2 = new StringBuilder(masterControl1);
stringBuilder2.reverse();
// 每两位转10进制数值int输出
String rstr = stringBuilder2.substring(0);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
return ss;
}
// 分机工作状态
public static StringBuilder getWorkStates(long num) {
String workStates = Integer.toBinaryString((int) ((num & 0xFF) + 0x100)).substring(1);
StringBuilder stringBuilder4 = new StringBuilder();
int a1 = 64 - workStates.length();
String bString1 = "0";
for (int i = 0; i < a1; i++) {
// stringBuilder3.append(b);
workStates = bString1 + workStates;
}
StringBuilder stringBuilder2 = new StringBuilder(workStates);
stringBuilder2.reverse();
// 每两位转10进制数值int输出
for (int i = 0; i < 64; i += 1) {
String rstr = stringBuilder2.substring(i, i + 1);
BigInteger bigInteger = new BigInteger(rstr, 2);
Integer ss = Integer.parseInt(bigInteger.toString());
stringBuilder4.append(ss);
}
return stringBuilder4;
}
// 解析雷达分机工作状态
private String radarWorkState(long num) {
String resultState = "";
String state = Long.toBinaryString(num);
int leftNum = 64 - state.length();
for (int i = 0; i < leftNum; i++) {
state = "0" + state;
}
resultState = resultState + state.substring(63, 64);// 0
resultState = resultState + state.substring(62, 63);// 1
resultState = resultState + state.substring(61, 62);// 2
resultState = resultState + state.substring(60, 61);// 3
resultState = resultState + state.substring(59, 60);// 4
resultState = resultState + state.substring(58, 59);// 5
resultState = resultState + state.substring(57, 58);// 6
resultState = resultState + state.substring(56, 57);// 7
resultState = resultState + state.substring(55, 56);// 8
resultState = resultState + state.substring(54, 55);// 9
resultState = resultState + state.substring(47, 48);// 16
resultState = resultState + state.substring(46, 47);// 17
resultState = resultState + state.substring(45, 46);// 18
resultState = resultState + state.substring(44, 45);// 19
resultState = resultState + state.substring(43, 44);// 20
resultState = resultState + state.substring(42, 43);// 21
resultState = resultState + state.substring(41, 42);// 22
resultState = resultState + state.substring(40, 41);// 23
resultState = resultState + state.substring(39, 40);// 24
resultState = resultState + state.substring(38, 39);// 25
resultState = resultState + state.substring(31, 32);// 32
resultState = resultState + state.substring(30, 31);// 33
resultState = resultState + state.substring(29, 30);// 34
resultState = resultState + state.substring(28, 29);// 35
resultState = resultState + state.substring(26, 27);// 37
resultState = resultState + state.substring(25, 26);// 38
resultState = resultState + state.substring(24, 25);// 39
resultState = resultState + state.substring(23, 24);// 40
resultState = resultState + state.substring(20, 21);// 43
resultState = resultState + state.substring(19, 20);// 44
resultState = resultState + state.substring(18, 19);// 45
resultState = resultState + state.substring(17, 18);// 46
resultState = resultState + state.substring(16, 17);// 47
resultState = resultState + state.substring(15, 16);// 48
resultState = resultState + state.substring(14, 15);// 49
resultState = resultState + state.substring(13, 14);// 50
resultState = resultState + state.substring(9, 10);// 54
resultState = resultState + state.substring(8, 9);// 55
resultState = resultState + state.substring(7, 8);// 56
resultState = resultState + state.substring(6, 7);// 57
return resultState;
}
// 时间码解析
private String longToBinaryString(long longNum) {
String binaryString = Long.toBinaryString(longNum);
int leftNum = 64 - binaryString.length();
for (int i = 0; i < leftNum; i++) {
binaryString = "0" + binaryString;
}
return binaryString;
}
private String errorCheck(byte value) {
String result = "";
String binaryString = Integer.toBinaryString(Byte.toUnsignedInt(value));
int leftNum = 8 - binaryString.length();
for (int i = 0; i < leftNum; i++) {
binaryString = "0" + binaryString;
}
result = result + binaryString.substring(7);
result = result + binaryString.substring(6, 7);
return result;
}
private String getBinaryString(byte b) {
String binaryString = Integer.toBinaryString(Byte.toUnsignedInt(b));
int leftNum = 8 - binaryString.length();
for (int i = 0; i < leftNum; i++) {
binaryString = "0" + binaryString;
}
return binaryString;
}
private String getBinaryString(short s) {
String binaryString = Integer.toBinaryString(s);
int leftNum = 16 - binaryString.length();
for (int i = 0; i < leftNum; i++) {
binaryString = "0" + binaryString;
}
return binaryString;
}
private String getLockingInfo(byte b) {
String binaryString = getBinaryString(b);
String result = "";
result = result + binaryString.substring(7);
result = result + binaryString.substring(5, 6);
result = result + binaryString.substring(2, 3);// 自检源锁定指示
return result;
}
private String getSystemWorkState(byte b) {
String binaryString = getBinaryString(b);
String resultstring = "";
resultstring = resultstring + binaryString.substring(7, 8);
resultstring = resultstring + binaryString.substring(6, 7);
return resultstring;
}
// 主控
private String getZhuKongJiShuNum1(byte b) {
String binaryString = getBinaryString(b);
String resultstring = "";
resultstring = resultstring + Integer.parseUnsignedInt(binaryString.substring(6, 8), 2);
resultstring = resultstring + Integer.parseUnsignedInt(binaryString.substring(4, 6), 2);
resultstring = resultstring + Integer.parseUnsignedInt(binaryString.substring(2, 4), 2);
return resultstring;
}
// 检测
private String getZhuKongJiShuNum2(byte b) {
String binaryString = getBinaryString(b);
String resultstring = "";
resultstring = resultstring + Integer.parseUnsignedInt(binaryString.substring(6, 8), 2);
resultstring = resultstring + Integer.parseUnsignedInt(binaryString.substring(4, 6), 2);
resultstring = resultstring + Integer.parseUnsignedInt(binaryString.substring(2, 4), 2);
return resultstring;
}
// 采样时钟解析
private String getSamplingClock(byte b) {
String binaryString = getBinaryString(b);
String resultstring = "";
resultstring = resultstring + binaryString.substring(7, 8);
resultstring = resultstring + binaryString.substring(6, 7);
return resultstring;
}
private String getBoardTemp(short s) {
String binaryString = getBinaryString(s);
String resultstring = "";
resultstring = resultstring + Short.parseShort(binaryString.substring(8, 16), 2) + ".";
resultstring = resultstring + Short.parseShort(binaryString.substring(0, 8), 2);
return resultstring;
}
private String getCardState(byte b) {
String binaryString = getBinaryString(b);
String resultstring = "";
resultstring = resultstring + binaryString.substring(7, 8);
resultstring = resultstring + binaryString.substring(6, 7);
resultstring = resultstring + binaryString.substring(5, 6);
resultstring = resultstring + binaryString.substring(4, 5);
resultstring = resultstring + binaryString.substring(3, 4);
resultstring = resultstring + binaryString.substring(2, 3);
resultstring = resultstring + binaryString.substring(1, 2);
resultstring = resultstring + binaryString.substring(0, 1);
return resultstring;
}
private void saveErrorLog(String host, String state) {
String deviceState = globalMap.get(host);
// 第一次初始化状态
if (deviceState == null || deviceState == "") {
globalMap.put(host, state);
return;
}
// 和取回的状态比较
if (!deviceState.equals(state)) {
for (int i = 0; i < state.length(); i++) {
char lastState = deviceState.charAt(i);
char nowState = state.charAt(i);
if (lastState != nowState) {
if (lastState == '0') {
SysErrorLogEntity sysErrorLogEntity = new SysErrorLogEntity();
sysErrorLogEntity.setCreateTime(new Date());
sysErrorLogEntity.setErrorType("组件故障");
sysErrorLogEntity.setErrorMsg(state);
sysErrorLogEntity.setHost(host);
sysErrorLogService.saveError(sysErrorLogEntity);
break;
}
}
}
}
globalMap.put(host, state);
}
}
7580
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
