package com.ard.tianyu.service.impl;
|
|
import com.ard.common.utils.ByteUtils;
|
import com.ard.tianyu.config.TyConfiguration;
|
import com.ard.tianyu.http.TyClient;
|
import com.ard.tianyu.model.cache.UavSignalInfoCache;
|
import com.ard.tianyu.model.cache.UavStateCache;
|
import com.ard.tianyu.model.cache.UavTelemetryDataCache;
|
import com.ard.tianyu.model.dto.BoxHistoryDTO;
|
import com.ard.tianyu.model.dto.BoxPhotosDTO;
|
import com.ard.tianyu.model.dto.BoxSettingsDTO;
|
import com.ard.tianyu.model.dto.camera.*;
|
import com.ard.tianyu.model.dto.control.AbsAngleControlDTO;
|
import com.ard.tianyu.model.dto.control.AngleControlDTO;
|
import com.ard.tianyu.model.dto.control.SpeedControlDTO;
|
import com.ard.tianyu.model.dto.converter.UavSignalInfoConverter;
|
import com.ard.tianyu.model.dto.converter.UavStateConverter;
|
import com.ard.tianyu.model.dto.converter.UavTelemetryDataConverter;
|
import com.ard.tianyu.model.dto.manual.*;
|
import com.ard.tianyu.model.dto.signal.SignalInfo;
|
import com.ard.tianyu.model.dto.state.UavState;
|
import com.ard.tianyu.model.dto.telemetry.TelemetryData;
|
import com.ard.tianyu.model.receiver.*;
|
import com.ard.tianyu.netty.command.*;
|
import com.ard.tianyu.netty.TyNettyTcpClient;
|
import com.ard.tianyu.netty.command.camera.*;
|
import com.ard.tianyu.netty.command.control.AbsAngleControlCmd;
|
import com.ard.tianyu.netty.command.control.AngleControlCmd;
|
import com.ard.tianyu.netty.command.control.SpeedControlCmd;
|
import com.ard.tianyu.netty.command.manual.*;
|
import com.ard.tianyu.netty.command.notice.BoxPowerStatusReplyCmd;
|
import com.ard.tianyu.netty.command.notice.FlyWayEndReplyCmd;
|
import com.ard.tianyu.netty.command.notice.UavReadyReplyCmd;
|
import com.ard.tianyu.netty.command.real.SignalInfoCmd;
|
import com.ard.tianyu.netty.command.real.UavStateCmd;
|
import com.ard.tianyu.netty.command.real.UavTelemetryDataCmd;
|
import com.ard.tianyu.netty.command.register.*;
|
import com.ard.tianyu.netty.handler.ErrorCodeEnum;
|
import com.ard.tianyu.service.ITyService;
|
import com.ard.tianyu.websocket.utils.WebSocketUtil;
|
import io.netty.channel.Channel;
|
import io.netty.channel.ChannelFuture;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.net.InetSocketAddress;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
/**
|
* TyServiceImpl
|
*
|
* @author liusuyi
|
* @date 2024年10月22日8:37
|
**/
|
@Slf4j
|
@Service
|
public class TyServiceImpl implements ITyService {
|
|
@Resource
|
private TyClient tyClient;
|
|
@Resource
|
private TyConfiguration tyConfiguration;
|
|
// 存储每个无人机的最后遥测处理时间
|
private Map<String, Long> lastTelemetryTimes = new ConcurrentHashMap<>();
|
|
/**
|
* 获取天宇token信息
|
*
|
* @return AccessTokenReceiver
|
*/
|
@Override
|
public AccessTokenReceiver getAccessToken() {
|
return tyConfiguration.getAccessToken();
|
}
|
|
/**
|
* 获取云盒列表
|
*
|
* @return List<BoxInfoReceiver>
|
*/
|
@Override
|
public List<BoxInfoReceiver> getBoxList() {
|
//请求云盒列表
|
try {
|
TyHttpCommonReceiver<List<BoxInfoReceiver>> boxListReveiver = tyClient.getBoxList(tyConfiguration.getAccessToken().convertFromDTO());
|
return boxListReveiver.getContent();
|
} catch (Exception e) {
|
log.error("获取云盒列表失败:{}", e.getMessage());
|
return new ArrayList<>();
|
}
|
}
|
|
/**
|
* 获取直播地址
|
*
|
* @return BoxStreamUrlReceiver
|
*/
|
@Override
|
public BoxStreamUrlReceiver getBoxLiveUrl(String boxSn) {
|
|
TyHttpCommonReceiver<BoxStreamUrlReceiver> boxLiveUrl = tyClient.getBoxLiveUrl(boxSn, tyConfiguration.getAccessToken().convertFromDTO());
|
return boxLiveUrl.getContent();
|
}
|
|
/**
|
* 获取飞行历史
|
*
|
* @return List<BoxHistoryReceiver>
|
*/
|
@Override
|
public List<BoxHistoryReceiver> getBoxHistory(BoxHistoryDTO boxHistoryDTO) {
|
TyHttpCommonReceiver<List<BoxHistoryReceiver>> boxHistory = tyClient.getBoxHistory(boxHistoryDTO, tyConfiguration.getAccessToken().convertFromDTO());
|
return boxHistory.getContent();
|
}
|
|
/**
|
* 获取盒子图片
|
*
|
* @return List<BoxPhotosReceiver>
|
*/
|
@Override
|
public List<BoxPhotosReceiver> getBoxPhotos(BoxPhotosDTO boxPhotosDTO) {
|
TyHttpCommonReceiver<List<BoxPhotosReceiver>> boxPhotos = tyClient.getBoxPhotos(boxPhotosDTO, tyConfiguration.getAccessToken().convertFromDTO());
|
return boxPhotos.getContent();
|
}
|
|
/**
|
* 修改云盒设置
|
*/
|
@Override
|
public Boolean updateBoxSettings(BoxSettingsDTO boxSettingsDTO) {
|
TyHttpCommonReceiver<?> result = tyClient.updateBoxSettings(boxSettingsDTO, tyConfiguration.getAccessToken().convertFromDTO());
|
return result.getState() == 1;
|
}
|
|
/**
|
* 注册天宇平台
|
*/
|
@Override
|
public void registerMessage() {
|
try {
|
AccessTokenReceiver tyToken = tyConfiguration.getAccessToken();
|
RegisterCmd registerMessage = new RegisterCmd(tyToken.getCompanyId(), tyToken.getAccessToken().getBytes());
|
this.sendMessage(tyConfiguration.getIpPort(), registerMessage);
|
} catch (Exception e) {
|
log.error("注册天宇平台失败:{}", e.getMessage());
|
}
|
}
|
|
/**
|
* 云台控制基于角度
|
*/
|
@Override
|
public void angleControl(AngleControlDTO angleControlDto) {
|
AngleControlCmd controlAngleCommand = new AngleControlCmd(angleControlDto);
|
this.sendMessage(tyConfiguration.getIpPort(), controlAngleCommand);
|
}
|
|
/**
|
* 云台绝对值控制(基于角度)
|
*/
|
@Override
|
public void absAngleControl(AbsAngleControlDTO absAngleControlDto) {
|
AbsAngleControlCmd absAngleControlCommand = new AbsAngleControlCmd(absAngleControlDto);
|
this.sendMessage(tyConfiguration.getIpPort(), absAngleControlCommand);
|
}
|
|
/**
|
* 云台转动(基于速度)
|
*/
|
@Override
|
public void speedControl(SpeedControlDTO speedControlDto) {
|
SpeedControlCmd speedControlCommand = new SpeedControlCmd(speedControlDto);
|
this.sendMessage(tyConfiguration.getIpPort(), speedControlCommand);
|
}
|
|
/**
|
* 设置相机模式
|
*/
|
@Override
|
public void updateCameraMode(CameraModeDTO cameraModeDTO) {
|
CameraModeCmd cameraModeCommand = new CameraModeCmd(cameraModeDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), cameraModeCommand);
|
}
|
|
/**
|
* 拍照
|
*/
|
@Override
|
public void capturePic(CapturePicDTO capturePicDto) {
|
updateCameraMode(CameraModeDTO.builder().boxSn(capturePicDto.getBoxSn()).actionParam((byte) 0x01).build());
|
CapturePicCmd capturePicCommand = new CapturePicCmd(capturePicDto);
|
this.sendMessage(tyConfiguration.getIpPort(), capturePicCommand);
|
}
|
|
/**
|
* 录像
|
*/
|
@Override
|
public void record(RecordDTO recordDto) {
|
BaseCmd baseCmd;
|
if (recordDto.getIsRecord()) {
|
updateCameraMode(CameraModeDTO.builder().boxSn(recordDto.getBoxSn()).actionParam((byte) 0x02).build());
|
baseCmd = new RecordStartCmd(recordDto);
|
} else {
|
baseCmd = new RecordStopCmd(recordDto);
|
}
|
this.sendMessage(tyConfiguration.getIpPort(), baseCmd);
|
}
|
|
/**
|
* 变倍
|
*/
|
@Override
|
public void zoom(ZoomDTO zoomDTO) {
|
ZoomCmd zoomCommand = new ZoomCmd(zoomDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), zoomCommand);
|
}
|
|
/**
|
* 变倍到指定倍数
|
*/
|
@Override
|
public void zoomToLevel(ZoomToLevelDTO zoomToLevelDTO) {
|
ZoomToLevelCmd zoomToLevelCommand = new ZoomToLevelCmd(zoomToLevelDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), zoomToLevelCommand);
|
}
|
|
/**
|
* 切换摄像头
|
*/
|
@Override
|
public void switchCamera(SwitchCameraDTO switchCameraDTO) {
|
SwitchCameraCmd switchCameraCmd = new SwitchCameraCmd(switchCameraDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), switchCameraCmd);
|
}
|
|
/**
|
* 切换视频源
|
*/
|
@Override
|
public void switchSource(SwitchSourceDTO switchSourceDTO) {
|
SwitchSourceCmd switchSourceCmd = new SwitchSourceCmd(switchSourceDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), switchSourceCmd);
|
}
|
|
/**
|
* 打开或关闭照片回传
|
*/
|
@Override
|
public void photoReturnToggle(PhotoReturnToggleDTO photoReturnToggleDTO) {
|
PhotoReturnToggleCmd photoReturnToggleCmd = new PhotoReturnToggleCmd(photoReturnToggleDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), photoReturnToggleCmd);
|
}
|
|
/**
|
* 切换无人机控制权
|
*/
|
@Override
|
public void switchUavControl(SwitchUavControlDTO switchUavControlDTO) {
|
SwitchUavControlCmd switchUavControlCmd = new SwitchUavControlCmd(switchUavControlDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), switchUavControlCmd);
|
}
|
|
/**
|
* 起飞
|
*/
|
@Override
|
public void takeOff(TakeOffDTO takeOffDTO) {
|
TakeOffCmd takeOffCmd = new TakeOffCmd(takeOffDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), takeOffCmd);
|
}
|
|
/**
|
* 返航
|
*/
|
@Override
|
public void returnHome(ReturnHomeDTO returnHomeDTO) {
|
ReturnHomeCmd returnHomeCmd = new ReturnHomeCmd(returnHomeDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), returnHomeCmd);
|
}
|
|
/**
|
* 取消返航
|
*/
|
@Override
|
public void returnHomeCancel(ReturnHomeCancelDTO returnHomeCancelDTO) {
|
ReturnHomeCancelCmd returnHomeCancelCmd = new ReturnHomeCancelCmd(returnHomeCancelDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), returnHomeCancelCmd);
|
}
|
|
/**
|
* 降落
|
*/
|
@Override
|
public void land(LandDTO landDTO) {
|
LandCmd landCmd = new LandCmd(landDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), landCmd);
|
}
|
|
/**
|
* 取消降落
|
*/
|
@Override
|
public void landCancel(LandCancelDTO landCancelDTO) {
|
LandCancelCmd landCancelCmd = new LandCancelCmd(landCancelDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), landCancelCmd);
|
}
|
|
/**
|
* 强制降落
|
*/
|
@Override
|
public void landForced(LandForcedDTO landForcedDTO) {
|
LandForcedCmd landForcedCmd = new LandForcedCmd(landForcedDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), landForcedCmd);
|
}
|
|
/**
|
* 方向控制
|
*/
|
@Override
|
public void flyControl(FlyControlDTO flyControlDTO) {
|
FlyControlCmd flyControlCmd = new FlyControlCmd(flyControlDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), flyControlCmd);
|
}
|
|
/**
|
* 指点飞行控制
|
*/
|
@Override
|
public void flyPointControl(FlyPointControlDTO flyPointControlDTO) {
|
FlyPointControlCmd flyPointControlCmd = new FlyPointControlCmd(flyPointControlDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), flyPointControlCmd);
|
}
|
|
/**
|
* 停止指点飞行控制
|
*/
|
@Override
|
public void flyPointControlCancel(FlyPointControlCancelDTO flyPointControlCancelDTO) {
|
FlyPointControlCancelCmd flyPointControlCancelCmd = new FlyPointControlCancelCmd(flyPointControlCancelDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), flyPointControlCancelCmd);
|
}
|
|
/**
|
* 紧急制动
|
*/
|
@Override
|
public void emeragencyBrake(EmeragencyBrakeDTO emeragencyBrakeDTO) {
|
EmergencyBrakeCmd emergencyBrakeCmd = new EmergencyBrakeCmd(emeragencyBrakeDTO);
|
this.sendMessage(tyConfiguration.getIpPort(), emergencyBrakeCmd);
|
}
|
|
/**
|
* 获取无人机状态
|
*/
|
@Override
|
public UavState getUavState(String boxSn) {
|
return UavStateCache.getUavState(boxSn);
|
}
|
|
/**
|
* 获取无人机遥测数据
|
*/
|
@Override
|
public TelemetryData getUavTelemetryData(String boxSn) {
|
return UavTelemetryDataCache.getUavTelemetryData(boxSn);
|
}
|
|
/**
|
* 获取无人机遥测数据
|
*/
|
@Override
|
public SignalInfo getSignalInfo(String boxSn) {
|
return UavSignalInfoCache.getUavSignalInfo(boxSn);
|
}
|
|
/**
|
* 处理天宇服务器返回的消息
|
*/
|
@Override
|
public void processReplyMessage(String key, BaseCmd tyCommand) {
|
byte cmdCode = tyCommand.getCmdCode();
|
switch (cmdCode) {
|
case 0x01:
|
// 处理心跳消息
|
RegisterReplyCmd registerReplyCommand = (RegisterReplyCmd) tyCommand;
|
logPrint("注册消息", registerReplyCommand.getSuccess());
|
if (registerReplyCommand.getSuccess() != 1) {
|
// 注册失败，重新注册
|
log.info("注册失败，重新注册");
|
registerMessage();
|
}
|
break;
|
case 0x02:
|
// 处理注册消息
|
HeartbeatReplyCmd heartbeatReplyCmd = (HeartbeatReplyCmd) tyCommand;
|
logPrint("心跳消息", heartbeatReplyCmd.getTimestamp());
|
break;
|
case 0x03:
|
// 处理订阅消息
|
break;
|
case 0x04:
|
// 处理取消订阅消息
|
break;
|
case 0x0A:
|
// 处理云盒开关机通知消息
|
BoxPowerStatusReplyCmd boxPowerStatusReplyCmd = (BoxPowerStatusReplyCmd) tyCommand;
|
logPrint("云盒开关机通知消息", boxPowerStatusReplyCmd.getStatus());
|
break;
|
case (byte) 0xA8:
|
// 处理无人机状态消息
|
UavStateCmd uavStateCmd = (UavStateCmd) tyCommand;
|
UavState uavState = UavStateConverter.convertProtoToEntity(uavStateCmd.getUavState());
|
UavStateCache.putUavState(uavState);
|
logPrint("无人机状态", uavState.getBoxSn());
|
WebSocketUtil.sendMessageAll(uavState);
|
break;
|
case (byte) 0xA9:
|
// 处理无人机遥测消息
|
UavTelemetryDataCmd uavTelemetryDataCmd = (UavTelemetryDataCmd) tyCommand;
|
String boxSn = ByteUtils.bytesToString(uavTelemetryDataCmd.getBoxSn()); // 假设有获取无人机ID的方法
|
long currentTime = System.currentTimeMillis();
|
|
// 获取无人机的最后处理时间，如果没有则设置为0
|
long lastTelemetryTime = lastTelemetryTimes.getOrDefault(boxSn, 0L);
|
|
// 检查与上次处理时间的间隔
|
if (currentTime - lastTelemetryTime >= 1000) { // 1秒
|
TelemetryData telemetryData = UavTelemetryDataConverter.convertProtoToEntity(uavTelemetryDataCmd.getTelemetryData());
|
UavTelemetryDataCache.putUavTelemetryData(telemetryData);
|
logPrint("无人机遥测", telemetryData.getBoxSn());
|
|
// 更新最后处理时间
|
lastTelemetryTimes.put(boxSn, currentTime);
|
} else {
|
log.debug("无人机 " + boxSn + " 遥测数据接收过于频繁，已跳过处理");
|
}
|
break;
|
|
case (byte) 0x0C:
|
// 处理无人机信道质量数据
|
SignalInfoCmd signalInfoCmd = (SignalInfoCmd) tyCommand;
|
SignalInfo signalInfo = UavSignalInfoConverter.convertProtoToEntity(signalInfoCmd.getSignalInfo());
|
UavSignalInfoCache.putUavSignalInfoCache(signalInfo);
|
logPrint("无人机信道质量", signalInfo.getBoxSn());
|
break;
|
case (byte) 0xD1:
|
// 处理无人机
|
if (tyCommand instanceof UavInitReplyCmd) {
|
UavInitReplyCmd uavInitReplyCmd = (UavInitReplyCmd) tyCommand;
|
UavInitInfoCmd uavInitCommand = new UavInitInfoCmd(uavInitReplyCmd.getBoxSn());
|
this.sendMessage(tyConfiguration.getIpPort(), uavInitCommand);
|
logPrint("无人机初始化详情", uavInitCommand.getBoxSn());
|
}
|
if (tyCommand instanceof UavReadyReplyCmd) {
|
UavReadyReplyCmd uavReadyReplyCmd = (UavReadyReplyCmd) tyCommand;
|
logPrint("无人机准备完成通知", uavReadyReplyCmd.getBatteryPower());
|
}
|
if (tyCommand instanceof CameraModeReplyCmd) {
|
CameraModeReplyCmd cameraModeReplyCommand = (CameraModeReplyCmd) tyCommand;
|
logPrint("无人机设置相机模式", cameraModeReplyCommand.getResult(), cameraModeReplyCommand.getErrorCode());
|
}
|
if (tyCommand instanceof FlyWayEndReplyCmd) {
|
FlyWayEndReplyCmd flyWayEndReplyCmd = (FlyWayEndReplyCmd) tyCommand;
|
logPrint("无人机飞行结束", flyWayEndReplyCmd.getResult(), flyWayEndReplyCmd.getErrorCode());
|
}
|
if (tyCommand instanceof CapturePicReplyCmd) {
|
CapturePicReplyCmd capturePicReplyCommand = (CapturePicReplyCmd) tyCommand;
|
logPrint("无人机拍照", capturePicReplyCommand.getResult(), capturePicReplyCommand.getErrorCode());
|
}
|
if (tyCommand instanceof RecordStartReplyCmd) {
|
RecordStartReplyCmd recordStartReplyCommand = (RecordStartReplyCmd) tyCommand;
|
logPrint("无人机开始录像", recordStartReplyCommand.getResult(), recordStartReplyCommand.getErrorCode());
|
}
|
if (tyCommand instanceof RecordStopReplyCmd) {
|
RecordStopReplyCmd recordStopReplyCommand = (RecordStopReplyCmd) tyCommand;
|
logPrint("无人机停止录像", recordStopReplyCommand.getResult(), recordStopReplyCommand.getErrorCode());
|
}
|
//起飞回复
|
if (tyCommand instanceof TakeOffReplyCmd) {
|
TakeOffReplyCmd takeOffReplyCommand = (TakeOffReplyCmd) tyCommand;
|
logPrint("无人机起飞", takeOffReplyCommand.getResult(), takeOffReplyCommand.getErrorCode());
|
}
|
//返航回复
|
if (tyCommand instanceof ReturnHomeReplyCmd) {
|
ReturnHomeReplyCmd returnHomeReplyCmd = (ReturnHomeReplyCmd) tyCommand;
|
logPrint("无人机返航", returnHomeReplyCmd.getResult(), returnHomeReplyCmd.getErrorCode());
|
}
|
//取消返航回复
|
if (tyCommand instanceof ReturnHomeCancelReplyCmd) {
|
ReturnHomeCancelReplyCmd returnHomeCancelReplyCmd = (ReturnHomeCancelReplyCmd) tyCommand;
|
logPrint("取消无人机返航", returnHomeCancelReplyCmd.getResult(), returnHomeCancelReplyCmd.getErrorCode());
|
}
|
//降落回复
|
if (tyCommand instanceof LandReplyCmd) {
|
LandReplyCmd landReplyCmd = (LandReplyCmd) tyCommand;
|
logPrint("降落", landReplyCmd.getResult(), landReplyCmd.getErrorCode());
|
}
|
//取消降落回复
|
if (tyCommand instanceof LandCancelReplyCmd) {
|
LandCancelReplyCmd landCancelReplyCmd = (LandCancelReplyCmd) tyCommand;
|
logPrint("取消降落", landCancelReplyCmd.getResult(), landCancelReplyCmd.getErrorCode());
|
}
|
//强制降落回复
|
if (tyCommand instanceof LandForcedReplyCmd) {
|
LandForcedReplyCmd landForcedReplyCmd = (LandForcedReplyCmd) tyCommand;
|
logPrint("强制降落", landForcedReplyCmd.getResult(), landForcedReplyCmd.getErrorCode());
|
}
|
//到达指点飞行位置回复
|
if (tyCommand instanceof PointControlReachedReplyCmd) {
|
PointControlReachedReplyCmd pointControlReachedReplyCmd = (PointControlReachedReplyCmd) tyCommand;
|
logPrint("到达指点飞行位置", pointControlReachedReplyCmd.getResult(), pointControlReachedReplyCmd.getErrorCode());
|
}
|
//紧急制动回复
|
if (tyCommand instanceof EmergencyBrakeReplyCmd) {
|
EmergencyBrakeReplyCmd emergencyBrakeReplyCmd = (EmergencyBrakeReplyCmd) tyCommand;
|
logPrint("紧急制动回复", emergencyBrakeReplyCmd.getResult(), emergencyBrakeReplyCmd.getErrorCode());
|
}
|
break;
|
default:
|
// 处理其他消息
|
log.warn("收到其他消息-->{}", tyCommand.getCmdCode());
|
}
|
}
|
|
//公共日志打印
|
private void logPrint(String message, Object obj) {
|
log.debug("收到{}回复{}", message, obj);
|
}
|
|
//公共日志打印
|
private void logPrint(String message, byte result, Integer errorCode) {
|
log.info("收到{}回复:{} 错误码：{}【{}】",
|
message,
|
ByteUtils.byteToHex(result),
|
errorCode,
|
ErrorCodeEnum.getDescByCode(errorCode));
|
}
|
|
/**
|
* 定时3秒发送心跳指令
|
*/
|
@Scheduled(fixedRate = 3000)
|
public void sendHeartBeat() {
|
long timestamp = System.currentTimeMillis();
|
log.debug("定时向天宇发送⼼跳,时间戳{}", timestamp);
|
HeartbeatCmd heartbeatMessage = new HeartbeatCmd(timestamp);
|
this.sendMessage(tyConfiguration.getIpPort(), heartbeatMessage);
|
}
|
|
/**
|
* 发送消息
|
*/
|
private void sendMessage(String key, BaseCmd msg) {
|
try {
|
ChannelFuture future = TyNettyTcpClient.channels.get(key).getChannelFuture();
|
Channel channel = future.channel();
|
if (channel.isActive()) {
|
InetSocketAddress ipSocket = (InetSocketAddress) channel.remoteAddress();
|
String host = ipSocket.getHostString();
|
int port = ipSocket.getPort();
|
channel.writeAndFlush(msg); // 发送编码后的数据
|
log.debug("向天宇服务器【{}:{}】发送数据，命令码：{}", host, port, String.format("0x%02X", msg.getCmdCode() & 0xFF));
|
} else {
|
log.error("与天宇服务器链接断开，无法发送数据！");
|
}
|
} catch (Exception e) {
|
log.error("发送消息异常：{}", e.getMessage());
|
}
|
}
|
}
|
