rfid采用tcp模拟

赣州-jastRFID
LAPTOP-S9HJSOEB\昊天 8 months ago
parent 2293fb5f70
commit f5803e276f

@ -1,17 +0,0 @@
package com.zhehekeji.web.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
@Configuration
public class WebSocketConfig {
/**
* 使SpringboottomcatServerEndpointbean
* 使webServerEndpointExporter
*/
@Bean
public ServerEndpointExporter serverEndpointExporter(){
return new ServerEndpointExporter();
}
}

@ -155,8 +155,12 @@ public class StockController {
log.info("stockCheck:res:{}",stock);
CheckInfo checkInfo= new CheckInfo();
if (stock!=null) {
checkInfo.setTrayCode(stock.getWmsTrayCode());
checkInfo.setTrayCode(stock.getTrayCode());
checkInfo.setCheckRlt(stock.getStatus() == 2 || stock.getStatus() == 3 ? 1 : 0);
checkInfo.setExportTime(stock.getExportTime());
checkInfo.setOrderNum(stock.getCheckNum().substring(stock.getCheckNum().lastIndexOf("_") + 1));
checkInfo.setWmsTrayCode(stock.getWmsTrayCode());
checkInfo.setWmsTrayCodes(stock.getCode().split(","));
}else {
checkInfo.setCheckRlt(0);

@ -3,9 +3,8 @@ package com.zhehekeji.web.controller;
import com.zhehekeji.core.pojo.Result;
import com.zhehekeji.web.entity.RFID;
import com.zhehekeji.web.entity.Street;
import com.zhehekeji.web.service.PlcCmdInfo;
import com.zhehekeji.web.service.RFID.RFIDMap;
import com.zhehekeji.web.service.RFID.RFIDSocket;
import com.zhehekeji.web.service.RFID.RFIDTCPClient;
import com.zhehekeji.web.service.RFIDService;
import com.zhehekeji.web.service.StreetService;
import com.zhehekeji.web.service.TestService;
@ -16,7 +15,6 @@ import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@Api(value = "TestController",tags = "扫码测试")
@ -46,77 +44,59 @@ public class TestController {
@GetMapping("/1")
public Result test(){
RFIDSocket rfidSocket = new RFIDSocket("127.0.0.1", 4001);
rfidSocket.startCheck(1,true);
try {
Thread.sleep(1000*15);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
rfidSocket.stopCheck();
System.out.println(rfidSocket.getTags());
return Result.success();
}
@Resource
StreetService streetService;
@Resource
RFIDService rfidService;
@ApiOperation("rfid")
@GetMapping("/rfid")
public Result<Set<String >> rfid(@PathVariable String streetId){
public Result<Set<String >> rfid(@RequestParam String streetId){
Street street = streetService.getStreetByPlcId(streetId);
RFIDSocket rfidSocket = new RFIDSocket(street.getPlcIp(), 4001);
rfidSocket.startCheck(1,true);
try {
Thread.sleep(1000*15);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
rfidSocket.stopCheck();
System.out.println(rfidSocket.getTags());
return Result.success(rfidSocket.getTags());
return Result.success();
}
@ApiOperation("rfidNew")
@GetMapping("/rfidNew")
public Result<Set<String >> rfidNew(@PathVariable String streetId) {
public Result<Set<String >> rfidNew(@RequestParam String streetId) {
Street street = streetService.getStreetByPlcId(streetId);
if (street != null) {
//rfid不分左右rfid使用同一ip和端口依靠传递字符调整方向
RFID rfid = rfidService.getRFIDByPlc(street.getId(), null);
if (rfid != null) {
RFIDStart(rfid.getIp(), rfid.getPort(), street.getId(), 1);
try {
Thread.sleep(1000*15);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Set<String> tags = RFIDStop(street);
return Result.success(tags);
return Result.success();
}
}
return Result.success(new HashSet<>());
}
public void RFIDStart(String ip, Integer port, Integer streetId, Integer direction) {
RFIDSocket rfidSocket = new RFIDSocket(ip, port);
log.info("rfid调用ip" + ip + ";port:" + port);
rfidSocket.startCheck(direction,false);
RFIDMap.put(streetId, rfidSocket);
}
@ApiOperation("rfidNewTid")
@GetMapping("/rfidNewTid")
public Result<Set<String >> rfidNewTid(@RequestParam String streetId) {
Street street = streetService.getStreetByPlcId(streetId);
if (street != null) {
//rfid不分左右rfid使用同一ip和端口依靠传递字符调整方向
RFID rfid = rfidService.getRFIDByPlc(street.getId(), null);
if (rfid != null) {
public Set<String> RFIDStop(Street street) {
RFIDSocket rfidSocket = RFIDMap.get(street.getId());
Set<String> tags = null;
if (rfidSocket != null) {
tags = rfidSocket.getTags();
log.info("tags:{}", tags);
rfidSocket.stopCheck();
RFIDMap.remove(street.getId());
Set<String> tags = RFIDStartTid(rfid.getIp(), rfid.getPort(), street.getId(), 1);
return Result.success(tags);
}
}
return Result.success(new HashSet<>());
}
public Set<String> RFIDStartTid(String ip, Integer port, Integer streetId, Integer direction) {
Set<String> tags = RFIDTCPClient.checkTid(ip, port);
return tags;
}
}

@ -1,9 +1,18 @@
package com.zhehekeji.web.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.Set;
@Data
public class CheckInfo {
private String trayCode;
private String wmsTrayCode;
private String[] wmsTrayCodes;
private String orderNum;
@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
private LocalDateTime exportTime;
private int checkRlt;
}

@ -1,45 +1,30 @@
package com.zhehekeji.web.service;
import codeDetector.BarcodeDetector;
import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhehekeji.common.util.PathUtil;
import com.zhehekeji.web.config.ConfigProperties;
import com.zhehekeji.web.config.WebSocketConfig;
import com.zhehekeji.web.entity.*;
import com.zhehekeji.web.lib.*;
import com.zhehekeji.web.mapper.*;
import com.zhehekeji.web.pojo.OrderVO;
import com.zhehekeji.web.pojo.websocket.WebSocketVo;
import com.zhehekeji.web.service.RFID.RFIDMap;
import com.zhehekeji.web.service.RFID.RFIDSocket;
import com.zhehekeji.web.service.RFID.RFIDSocketOld;
import com.zhehekeji.web.service.hikLightSource.HikControlSocket;
import com.zhehekeji.web.service.interfaces.RfidLiveService;
import com.zhehekeji.web.service.ksec.KsecNettyClient;
import com.zhehekeji.web.service.sick.SickSocket;
import com.zhehekeji.web.util.ToolUtil;
import com.zhehekeji.web.ws.WebSocketServer;
import io.swagger.models.auth.In;
import jdk.internal.joptsimple.internal.Strings;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.SetUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.poi.util.ArrayUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
import static com.zhehekeji.web.service.RFID.RFIDTCPClient.checkTid;
/**
* @Description plc
@ -654,55 +639,52 @@ public class PlcService {
Boolean trayRFIDCheck = Boolean.FALSE;
Future<Boolean> rfidFuture = executor.submit(() -> {
long startRfidTime = System.currentTimeMillis();
Boolean flag = Boolean.FALSE;;
long startRfidTime = System.currentTimeMillis();
Boolean flag = Boolean.FALSE;
;
Set<String> tags = new HashSet<>();
try {
RFIDCheck(plcCmdInfo, true);
Thread.sleep(1000 * configProperties.getRfid().getScanTime());
} catch (Exception e) {
e.printStackTrace();
} finally {
tags = RFIDStop(plcCmdInfo);
log.info("盘点rfid扫描结果" + tags);
}
if (tags != null && tags.size() > 0) {
if ( wmsTrayCode != null
&& tags.contains(wmsTrayCode)) {
log.info("扫描成功");
flag = Boolean.TRUE;
} else {
Set<String> tags = new HashSet<>();
try {
tags = RFIDCheck(plcCmdInfo, true);
Thread.sleep(1000 * configProperties.getRfid().getScanTime());
} catch (Exception e) {
e.printStackTrace();
} finally {
log.info("盘点rfid扫描结果" + tags);
}
if (tags != null && tags.size() > 0) {
flag = Boolean.FALSE;;
}
RFID rfid = rfidMapper.selectOne(new QueryWrapper<RFID>().eq("street_id", street.getId()));
if (!rfidLiveService.getRfidLive(plcCmdInfo, street, wmsTrayCode)) {
rfidLiveService.rfidRemoveLive(plcCmdInfo, street, rfid);
}
rfidLiveService.rfidSave(plcCmdInfo, String.join(",", tags), street, rfid);
}
if (wmsTrayCode != null
&& tags.contains(wmsTrayCode)) {
log.info("扫描成功");
flag = Boolean.TRUE;
} else {
long endRfidTime = System.currentTimeMillis();
flag = Boolean.FALSE;
;
}
RFID rfid = rfidMapper.selectOne(new QueryWrapper<RFID>().eq("street_id", street.getId()));
if (!rfidLiveService.getRfidLive(plcCmdInfo, street, wmsTrayCode)) {
rfidLiveService.rfidRemoveLive(plcCmdInfo, street, rfid);
}
rfidLiveService.rfidSave(plcCmdInfo, String.join(",", tags), street, rfid);
}
log.info("rfid time:{}millisecond", startRfidTime - endRfidTime);
return flag;
long endRfidTime = System.currentTimeMillis();
});
try {
log.info("rfid time:{}millisecond", startRfidTime - endRfidTime);
// String sickCode = sickFuture.get(); // get()会阻塞直到结果可用
Boolean rfid = rfidFuture.get(); // get()会阻塞直到结果可用
log.info("rfid:{}", rfid);
Boolean rfid = flag; // get()会阻塞直到结果可用
log.info("rfid:{}", rfid);
trayRFIDCheck = rfid;
trayRFIDCheck = rfid;
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
if (tags == null) {
tags = new HashSet<>();
}
String tagStr = String.join(",", tags);
log.info("rfid tagsStr:{}", tagStr);
OrderInfo orderInfo = new OrderInfo(street, plcCmdInfo, 1, cmdCode);
Stock stock = stockMapper.getByStreetAndDirectionAndSideAndRowColumn(orderInfo.getStreetId(), plcCmdInfo.getFromDirection(), orderInfo.getSeparation(), orderInfo.getRow(), orderInfo.getColumn());
String scanCode = null;
@ -711,23 +693,24 @@ public class PlcService {
//核对异常
Integer status = 1;
//托盘和货物都正确
if ( trayRFIDCheck) {
if (trayRFIDCheck) {
status = 2;
trayCode=wmsTrayCode;
}else {
trayCode="盘点失败";
trayCode = wmsTrayCode;
} else {
trayCode = "盘点失败";
}
if (stock == null) {
stock = Stock.builder()
.checkNum(plcCmdInfo.getOrderNum())
.lotnum(plcCmdInfo.getLotnum())
.code(scanCode)
// .code(scanCode)
.wmsCode(wmsCode)
.wmsTrayCode(wmsTrayCode)
.trayCode(trayCode)
.streetId(orderInfo.getStreetId())
.direction(plcCmdInfo.getFromDirection())
.side(orderInfo.getSeparation())
.code(tagStr)
.row(orderInfo.getRow())
.column(orderInfo.getColumn())
.status(status)
@ -739,8 +722,9 @@ public class PlcService {
stock.setExportTime(LocalDateTime.now());
stock.setCheckNum(plcCmdInfo.getOrderNum());
stock.setTrayCode(trayCode);
stock.setCode(tagStr);
stock.setWmsTrayCode(wmsTrayCode);
stock.setCode(scanCode);
// stock.setCode(scanCode);
stock.setWmsCode(wmsCode);
stockMapper.updateById(stock);
}
@ -751,16 +735,16 @@ public class PlcService {
long end = System.currentTimeMillis();
long s = end - startTime;
log.info("time:{}millisecond", s);
WebSocketVo<PlcCmdInfo> webSocketVo = WebSocketVo.<PlcCmdInfo>builder()
.message(plcCmdInfo)
.messageType("object")
.type("InventoryPush")
.build();
try {
WebSocketServer.sendInfo(JSONObject.toJSONString(webSocketVo), "");
} catch (IOException e) {
throw new RuntimeException(e);
}
// WebSocketVo<PlcCmdInfo> webSocketVo = WebSocketVo.<PlcCmdInfo>builder()
// .message(plcCmdInfo)
// .messageType("object")
// .type("InventoryPush")
// .build();
// try {
// WebSocketServer.sendInfo(JSONObject.toJSONString(webSocketVo), "");
// } catch (IOException e) {
// throw new RuntimeException(e);
// }
return true;
}
@ -794,39 +778,19 @@ public class PlcService {
* @param plcCmdInfo
* @param fromOrTo
*/
public void RFIDCheck(PlcCmdInfo plcCmdInfo, boolean fromOrTo) {
public Set<String> RFIDCheck(PlcCmdInfo plcCmdInfo, boolean fromOrTo) {
log.info("开启rfid");
Street street = streetService.getStreetByPlcId(plcCmdInfo.getPlcId());
if (street != null) {
//rfid不分左右rfid使用同一ip和端口依靠传递字符调整方向
RFID rfid = rfidService.getRFIDByPlc(street.getId(), null);
if (rfid != null) {
if (fromOrTo) {
RFIDStart(rfid.getIp(), rfid.getPort(), street.getId(), plcCmdInfo.getFromDirection());
} else
RFIDStart(rfid.getIp(), rfid.getPort(), street.getId(), plcCmdInfo.getToDirection());
}
}
}
public void RFIDStart(String ip, Integer port, Integer streetId, Integer direction) {
RFIDSocket rfidSocket = new RFIDSocket(ip, port);
log.info("rfid调用ip" + ip + ";port:" + port);
rfidSocket.startCheck(direction,false);
RFIDMap.put(streetId, rfidSocket);
}
return checkTid(rfid.getIp(), rfid.getPort());
public Set<String> RFIDStop(PlcCmdInfo plcCmdInfo) {
Street street = streetService.getStreetByPlcId(plcCmdInfo.getPlcId());
RFIDSocket rfidSocket = RFIDMap.get(street.getId());
Set<String> tags = null;
if (rfidSocket != null) {
tags = rfidSocket.getTags();
log.info("tags:{}", tags);
rfidSocket.stopCheck();
RFIDMap.remove(street.getId());
}
return tags;
}
}
return new HashSet<>();
}

@ -0,0 +1,19 @@
package com.zhehekeji.web.service.RFID;
import lombok.Data;
@Data
public class RFIDData {
private String pc;
private String epc;
private String crc;
private String tid;
public RFIDData(String pc, String epc, String crc, String tid) {
this.pc = pc;
this.epc = epc;
this.crc = crc;
this.tid = tid;
}
}

@ -5,18 +5,4 @@ import java.util.Map;
public class RFIDMap {
private static Map<Integer,RFIDSocket> socketMap = new HashMap<>();
public static void put(Integer streetId,RFIDSocket rfidSocket){
socketMap.put(streetId,rfidSocket);
}
public static void remove(Integer streetId){
socketMap.remove(streetId);
}
public static RFIDSocket get(Integer streetId){
return socketMap.get(streetId);
}
}

@ -1,579 +0,0 @@
package com.zhehekeji.web.service.RFID;
import com.payne.reader.Reader;
import com.payne.reader.base.Consumer;
import com.payne.reader.bean.config.AntennaCount;
import com.payne.reader.bean.config.BaudRate;
import com.payne.reader.bean.config.Beeper;
import com.payne.reader.bean.config.ClearMaskId;
import com.payne.reader.bean.config.CmdStatus;
import com.payne.reader.bean.config.FastTidType;
import com.payne.reader.bean.config.GpioInType;
import com.payne.reader.bean.config.ProfileId;
import com.payne.reader.bean.receive.AntConnectionDetector;
import com.payne.reader.bean.receive.E710LinkProfile;
import com.payne.reader.bean.receive.Failure;
import com.payne.reader.bean.receive.FreqRegionResult;
import com.payne.reader.bean.receive.GpioOut;
import com.payne.reader.bean.receive.ImpinjFastTid;
import com.payne.reader.bean.receive.MaskInfo;
import com.payne.reader.bean.receive.MatchInfo;
import com.payne.reader.bean.receive.OperationTag;
import com.payne.reader.bean.receive.OutputPower;
import com.payne.reader.bean.receive.ReaderIdentifier;
import com.payne.reader.bean.receive.ReaderStatus;
import com.payne.reader.bean.receive.ReaderTemperature;
import com.payne.reader.bean.receive.ReceiveData;
import com.payne.reader.bean.receive.RfLinkProfile;
import com.payne.reader.bean.receive.RfPortReturnLoss;
import com.payne.reader.bean.receive.Success;
import com.payne.reader.bean.receive.TempLabel2;
import com.payne.reader.bean.receive.Version;
import com.payne.reader.bean.receive.WorkAntenna;
import com.payne.reader.bean.send.CustomSessionReadConfig;
import com.payne.reader.bean.send.FreqNormal;
import com.payne.reader.bean.send.FreqUserDefine;
import com.payne.reader.bean.send.Identifier;
import com.payne.reader.bean.send.InventoryConfig;
import com.payne.reader.bean.send.KillConfig;
import com.payne.reader.bean.send.LockConfig;
import com.payne.reader.bean.send.MaskConfig;
import com.payne.reader.bean.send.MatchConfig;
import com.payne.reader.bean.send.MultiAntReadTagConfig;
import com.payne.reader.bean.send.OutputPowerConfig;
import com.payne.reader.bean.send.ReadConfig;
import com.payne.reader.bean.send.TempLabel2Config;
import com.payne.reader.bean.send.WriteConfig;
import com.payne.reader.communication.ConnectHandle;
import com.payne.reader.communication.DataPacket;
import java.security.InvalidParameterException;
/**
*
*/
public interface RFIDReader extends Reader {
/**
*
*
* @param var1
* @return
*/
boolean connect(ConnectHandle var1);
/**
* 线
*
* @param var1
* @param var2 线
* @return
*/
boolean connect(ConnectHandle var1, boolean var2);
/**
*
*
* @return
*/
boolean isConnected();
/**
*
*/
void disconnect();
/**
*
*
* @return
*/
byte getReaderAddress();
/**
* 线
*
* @return 线
*/
AntennaCount getAntennaCount();
/**
* 线
*
* @param var1 线
*/
void switchAntennaCount(AntennaCount var1);
/**
*
*
* @param var1
*/
void setCmdTimeout(long var1);
/**
*
*
* @param var1
*/
void reset(Consumer<Failure> var1);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setBaudRate(BaudRate var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @param var2
* @param var3
* @param var4
*/
void setBaudRate(BaudRate var1, Consumer<Success> var2, Consumer<Failure> var3, Consumer<Throwable> var4);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setReaderAddress(byte var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @param var2
*/
void getFirmwareVersion(Consumer<Version> var1, Consumer<Failure> var2);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setBeeperMode(Beeper var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @param var2
*/
void getReaderTemperature(Consumer<ReaderTemperature> var1, Consumer<Failure> var2);
/**
* GPIO
*
* @param var1 GPIO
* @param var2
*/
void readGpio(Consumer<GpioOut> var1, Consumer<Failure> var2);
/**
* GPIO
*
* @param var1 GPIO
* @param var2
* @param var3
* @param var4
*/
void writeGpio(GpioInType var1, boolean var2, Consumer<Success> var3, Consumer<Failure> var4);
/**
* 线
*
* @param var1
* @param var2
* @param var3
*/
void setAntConnectionDetector(byte var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
* 线
*
* @param var1
* @param var2
*/
void getAntConnectionDetector(Consumer<AntConnectionDetector> var1, Consumer<Failure> var2);
/**
* 线
*
* @param var1 线
* @param var2
* @param var3
* @throws InvalidParameterException
*/
void setWorkAntenna(int var1, Consumer<Success> var2, Consumer<Failure> var3) throws InvalidParameterException;
/**
* 线
*
* @param var1 线
* @param var2
*/
void getWorkAntenna(Consumer<WorkAntenna> var1, Consumer<Failure> var2);
/**
* 线
*
* @return 线
*/
int getCacheWorkAntenna();
/**
* 线
*
* @return 线
*/
int getCacheAntennaGroup();
/**
*
*
* @param var1
* @param var2
* @param var3
* @throws InvalidParameterException
*/
void setOutputPower(OutputPowerConfig var1, Consumer<Success> var2, Consumer<Failure> var3) throws InvalidParameterException;
/**
*
*
* @param var1
* @param var2
*/
void getOutputPower(Consumer<OutputPower> var1, Consumer<Failure> var2);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setOutputPowerUniformly(byte var1, boolean var2, Consumer<Success> var3, Consumer<Failure> var4);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setFrequencyRegion(FreqNormal var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setUserDefineFrequency(FreqUserDefine var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @param var2
*/
void getFrequencyRegion(Consumer<FreqRegionResult> var1, Consumer<Failure> var2);
/**
*
*
* @param var1
* @param var2
* @param var3
*/
void setReaderIdentifier(Identifier var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @param var2
*/
void getReaderIdentifier(Consumer<ReaderIdentifier> var1, Consumer<Failure> var2);
/**
* RF
*
* @param var1
* @param var2
* @param var3
*/
void setRfLinkProfile(ProfileId var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
* RF
*
* @param var1 RF
* @param var2
*/
void getRfLinkProfile(Consumer<RfLinkProfile> var1, Consumer<Failure> var2);
/**
* E710
*
* @param var1
* @param var2
* @param var3
* @param var4
*/
void setE710LinkProfile(ProfileId var1, byte var2, Consumer<Success> var3, Consumer<Failure> var4);
/**
* E710
*
* @param var1 E710
* @param var2
*/
void getE710LinkProfile(Consumer<E710LinkProfile> var1, Consumer<Failure> var2);
/**
* RF
*
* @param var1
* @param var2
* @param var3
*/
void getRfPortReturnLoss(byte var1, Consumer<RfPortReturnLoss> var2, Consumer<Failure> var3);
/**
*
*
* @param var1
* @throws InvalidParameterException
*/
void setInventoryConfig(InventoryConfig var1) throws InvalidParameterException;
/**
*
*
* @param var1 线
*/
void startInventory(boolean var1);
/**
*
*/
void stopInventory();
/**
*
*
* @param var1
*/
void stopInventory(boolean var1);
/**
* MultiAntReadTagConfig
*
* @param var1 MultiAntReadTagConfig
*/
void setMultiAntReadTagConfig(MultiAntReadTagConfig var1);
/**
* MultiAntReadTag
*/
void startMultiAntReadTag();
/**
* MultiAntReadTag
*/
void stopMultiAntReadTag();
/**
*
*
* @param var1 ReadConfig
* @param var2
* @param var3
*/
void readTag(ReadConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
/**
*
*
* @param var1 CustomSessionReadConfig
* @param var2
* @param var3
*/
void readTag(CustomSessionReadConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
/**
*
*
* @param var1 WriteConfig
* @param var2
* @param var3
* @param var4
*/
void writeTag(WriteConfig var1, boolean var2, Consumer<OperationTag> var3, Consumer<Failure> var4);
/**
*
*
* @param var1 LockConfig
* @param var2
* @param var3
*/
void lockTag(LockConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
/**
*
*
* @param var1 KillConfig
* @param var2
* @param var3
*/
void killTag(KillConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
/**
* ImpinjFastTid
*
* @param var1 FastTidType
* @param var2
* @param var3
* @param var4
*/
void setImpinjFastTid(FastTidType var1, boolean var2, Consumer<Success> var3, Consumer<Failure> var4);
/**
* ImpinjFastTid
*
* @param var1
* @param var2
*/
void getImpinjFastTid(Consumer<ImpinjFastTid> var1, Consumer<Failure> var2);
/**
* EpcMatch
*
* @param var1 MatchConfig
* @param var2
* @param var3
*/
void setEpcMatch(MatchConfig var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
* EpcMatch
*
* @param var1
* @param var2
*/
void getEpcMatch(Consumer<MatchInfo> var1, Consumer<Failure> var2);
/**
* EpcMatch
*
* @param var1
* @param var2
*/
void clearEpcMatch(Consumer<Success> var1, Consumer<Failure> var2);
/**
* TagMask
*
* @param var1 MaskConfig
* @param var2
* @param var3
*/
void setTagMask(MaskConfig var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
* TagMask
*
* @param var1
* @param var2
*/
void getTagMask(Consumer<MaskInfo> var1, Consumer<Failure> var2);
/**
* TagMask
*
* @param var1 TagMaskID
* @param var2
* @param var3
*/
void clearTagMask(ClearMaskId var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
* ReaderStatus
*
* @param var1
* @param var2
* @param var3
*/
void setReaderStatus(byte var1, Consumer<Success> var2, Consumer<Failure> var3);
/**
* ReaderStatus
*
* @param var1
* @param var2
*/
void getReaderStatus(Consumer<ReaderStatus> var1, Consumer<Failure> var2);
/**
* TempLabel2
*
* @param var1 TempLabel2
* @param var2
*/
void measTempLabel2(TempLabel2Config var1, Consumer<TempLabel2> var2, Consumer<Failure> var3);
/**
* CommandStatusCallback
*
* @param var1
*/
void setCommandStatusCallback(Consumer<CmdStatus> var1);
/**
* OriginalDataCallback
*
* @param var1
* @param var2
*/
void setOriginalDataCallback(Consumer<byte[]> var1, Consumer<byte[]> var2);
/**
* UndefinedResultCallback
*
* @param var1
*/
void setUndefinedResultCallback(Consumer<ReceiveData> var1);
/**
* @deprecated 使
*/
@Deprecated
void sendCustomRequest(byte var1, byte[] var2);
/**
*
*
* @param var1
*/
void sendCustomRequest(DataPacket var1);
/**
* SdkBuildInfo
*
* @return SdkBuildInfo
*/
default String getSdkBuildInfo() {
return "add cmd:89, packaged at 2022-10-13 04.00";
}
}

@ -1,186 +0,0 @@
package com.zhehekeji.web.service.RFID;
import com.payne.connect.net.NetworkHandle;
import com.payne.reader.Reader;
import com.payne.reader.base.Consumer;
import com.payne.reader.bean.config.AntennaCount;
import com.payne.reader.bean.receive.*;
import com.payne.reader.bean.send.FastSwitchFourAntennaInventory;
import com.payne.reader.bean.send.InventoryConfig;
import com.payne.reader.process.ReaderImpl;
import com.payne.reader.util.ArrayUtils;
import com.zhehekeji.web.util.ToolUtil;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class RFIDSocket {
private String ip;
private int port;
private boolean running;
Reader mReader;
private Set<String> tags = new HashSet<>();
private Map<String, Integer> tagsCount = new ConcurrentHashMap<>();
public static void main(String[] args) {
String tagStr = "363000145224505289907900";
if(tagStr.startsWith("363000") &&tagStr.endsWith("00")){
tagStr = tagStr.substring(0, tagStr.length() - 2);
}
System.out.println(tagStr);
}
public Set<String> getTags() {
return tags;
}
public RFIDSocket(String ip, Integer port) {
this.ip = ip;
this.port = port;
NetworkHandle handle = new NetworkHandle(ip, (port));
mReader = ReaderImpl.create(AntennaCount.FOUR_CHANNELS);
boolean linkSuccess =false;
try {
linkSuccess = mReader.connect(handle);
}catch (Exception e) {
e.printStackTrace();
}
if (linkSuccess) {
System.out.println("reader1 connect success");
} else {
throw new RuntimeException("reader1 connect fail");
}
}
/**
*
* @param direction
* @param foreach 线
*/
public void startCheck(Integer direction,boolean foreach) {
// Reader mReader = ReaderImpl.create(AntennaCount.SIXTEEN_CHANNELS);
// Reader mReader = ReaderImpl.create(AntennaCount.EIGHT_CHANNELS);
running = true;
Thread thread = new Thread(new Runnable() {
public void run() {
mReader.setOriginalDataCallback(
new Consumer<byte[]>() {
@Override
public void accept(byte[] onSend) throws Exception {
//System.out.println("---reader 1 send :" + ArrayUtils.bytesToHexString(onSend, 0, onSend.length));
}
},
new Consumer<byte[]>() {
@Override
public void accept(byte[] onReceive) throws Exception {
}
});
FastSwitchFourAntennaInventory inventory = new FastSwitchFourAntennaInventory.Builder().build();
InventoryConfig config = new InventoryConfig.Builder()
.setInventory(inventory)
.setOnInventoryTagSuccess(new Consumer<InventoryTag>() {
@Override
public void accept(InventoryTag tag) throws Exception {
System.out.println("reader1 inventory tag :" + tag.getEpc());
String tagStr = tag.getEpc().replace(" ","");
tagStr = tagStr.substring(tagStr.length() - 8);
tags.add(tagStr);
if (ToolUtil.isNotEmpty(tagsCount.get(tagStr))) {
tagsCount.put(tagStr, tagsCount.get(tagStr) + 1);
} else {
tagsCount.put(tagStr, 1);
}
}
})
.setOnInventoryTagEndSuccess(new Consumer<InventoryTagEnd>() {
@Override
public void accept(InventoryTagEnd arg0) throws Exception {
// System.out.println("reader1 InventoryTagEnd");
}
})
.setOnFailure(new Consumer<InventoryFailure>() {
@Override
public void accept(InventoryFailure failure) throws Exception {
System.out.println("reader1 inventory fail :" + (failure.getErrorCode() & 0xFF));
}
})
.build();
mReader.setInventoryConfig(config);
mReader.startInventory(true);
mReader.setWorkAntenna(direction,
new Consumer<Success>() {
@Override
public void accept(Success success) throws Exception {
//切换天线
//处理成功
}
}, new Consumer<Failure>() {
@Override
public void accept(Failure failure) throws Exception {
//处理失败情况
}
}
);
byte[] bytes = new byte[1];
bytes[0] = 0x01;
while (running) {
try {
bytes[0] = (byte) (bytes[0] == 0x01 ? 0x00 : 0x01);
Thread.sleep(1000);
if(foreach){
mReader.setWorkAntenna(bytes[0],(v)->{
System.out.println("reader1 setWorkAntenna success");
},(v)->{
System.out.println("reader1 setWorkAntenna fail");
});
}
} catch (Exception e) {
e.printStackTrace();
stopCheck();
}
}
}
});
thread.start();
}
public void stopCheck() {
running = false;
System.out.println("reader1 stop");
if (mReader != null) {
mReader.stopInventory();
mReader.disconnect();
}
}
public String getTag() {
if (ToolUtil.isNotEmpty(tagsCount)) {
int i = 0;
String tag = "";
for (String t : tagsCount.keySet()) {
if (i < tagsCount.get(t)) {
tag = t;
i = tagsCount.get(t);
}
}
return tag;
}
return "";
}
}

@ -1,162 +0,0 @@
package com.zhehekeji.web.service.RFID;
import com.module.interaction.RXTXListener;
import com.module.interaction.ReaderHelper;
import com.rfid.RFIDReaderHelper;
import com.rfid.ReaderConnector;
import com.rfid.rxobserver.RXObserver;
import com.rfid.rxobserver.bean.RXInventoryTag;
import com.rfid.bean.MessageTran;
import com.util.StringTool;
import com.zhehekeji.web.util.ToolUtil;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class RFIDSocketOld {
private String ip;
private int port;
private ReaderHelper mReaderHelper;
private ReaderConnector mReaderConnector;
private boolean running;
private Set<String> tags = new HashSet<>();
private Map<String,Integer> tagsCount = new ConcurrentHashMap<>();
public Set<String> getTags(){
return tags;
}
private Observer mObserver = new RXObserver() {
@Override
protected void onInventoryTag(RXInventoryTag tag) {
System.out.println("EPC data:" + tag.strEPC);
}
@Override
protected void onInventoryTagEnd(RXInventoryTag.RXInventoryTagEnd endTag) {
System.out.println("inventory end:" + endTag.mTotalRead);
((RFIDReaderHelper) mReaderHelper).realTimeInventory((byte) 0xff,(byte)0x01);
}
@Override
protected void onExeCMDStatus(byte cmd,byte status) {
System.out.format("CDM:%s Execute status:%S\n",
String.format("%02X",cmd),String.format("%02x", status));
}
};
private RXTXListener mListener = new RXTXListener() {
@Override
//获取接收器返回的数据
public void reciveData(byte[] btAryReceiveData) {
// TODO Auto-generated method stub
System.out.println("reciveData: " + StringTool.byteArrayToString(btAryReceiveData, 0, btAryReceiveData.length));
MessageTran messageTran = new MessageTran(btAryReceiveData);
if (messageTran != null){
System.out.println("ary data length: " + messageTran.getAryData().length);
System.out.println("artData: " + StringTool.byteArrayToString(messageTran.getAryData(), 0, messageTran.getAryData().length));
StringBuffer sb = new StringBuffer();
int aryDataLength = messageTran.getAryData().length;
if (aryDataLength > 8){
for (int i = 0; i < aryDataLength; ++i){
sb.append(java.lang.String.format("%02X",messageTran.getAryData()[i]));
}
String tag = sb.toString();
//int index = st.indexOf("E");
//String tag = st.substring(index, index+16);
System.out.println("tag: "+tag);
tags.add(tag);
if(ToolUtil.isNotEmpty(tagsCount.get(tag))){
tagsCount.put(tag, tagsCount.get(tag)+1);
}else{
tagsCount.put(tag, 1);
}
}
}
}
@Override
public void sendData(byte[] btArySendData) {
// TODO Auto-generated method stub
System.out.println("sendData: " + StringTool.byteArrayToString(btArySendData, 0, btArySendData.length));
}
@Override
public void onLostConnect() {
// TODO Auto-generated method stub
}
};
public RFIDSocketOld(String ip, Integer port){
mReaderConnector = new ReaderConnector();
mReaderHelper = mReaderConnector.connectNet(ip, port);
}
public void startCheck(Integer direction){
running = true;
Thread thread = new Thread(new Runnable() {
public void run() {
if (mReaderHelper != null) {
System.out.println("Connect success!");
try {
mReaderHelper.registerObserver(mObserver);
mReaderHelper.setRXTXListener(mListener);
Thread.sleep(500);
//start to find the tags
// ((RFIDReaderHelper) mReaderHelper).realTimeInventory((byte) 0xff,(byte)0x01);
while (true) {
// if (i%2==0){
if (!running){
break;
}
if (direction == 1) {
//切换天线 0x00天线10x01天线2
((RFIDReaderHelper) mReaderHelper).setWorkAntenna((byte) 0xFF, (byte) 0x00);
} else {
((RFIDReaderHelper) mReaderHelper).setWorkAntenna((byte) 0xFF, (byte) 0x01);
}
//开始盘存180006B
//((RFIDReaderHelper) mReaderHelper).iso180006BInventory((byte) 0xFF);
((RFIDReaderHelper) mReaderHelper).inventory((byte) 0xFF, (byte) 0x0A);
// i++;
Thread.sleep(70);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
System.out.println("Connect faild!");
mReaderConnector.disConnect();
}
}
});
thread.start();
}
public void stopCheck(){
running = false;
if (mReaderConnector.isConnected()){
mReaderConnector.disConnect();
}
}
public String getTag(){
if(ToolUtil.isNotEmpty(tagsCount)){
int i = 0;
String tag = "" ;
for (String t : tagsCount.keySet()){
if (i<tagsCount.get(t)) {
tag = t;
i = tagsCount.get(t);
}
}
return tag;
}return "";
}
}

@ -0,0 +1,231 @@
package com.zhehekeji.web.service.RFID;
import lombok.extern.slf4j.Slf4j;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
@Slf4j
public class RFIDTCPClient {
private Socket socket;
private OutputStream outputStream;
private InputStream inputStream;
private String host;
private int port;
public RFIDTCPClient(String host, int port) {
this.host = host;
this.port = port;
}
public boolean connect() {
try {
socket = new Socket(host, port);
socket.setSoTimeout(200);
outputStream = socket.getOutputStream();
inputStream = socket.getInputStream();
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
public void disconnect() {
try {
if (outputStream != null) {
outputStream.close();
}
if (inputStream != null) {
inputStream.close();
}
if (socket != null) {
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void sendHexCommand(String hexCommand) throws IOException {
byte[] bytes = hexStringToByteArray(hexCommand);
outputStream.write(bytes);
outputStream.flush();
}
public Set<RFIDData> receiveRFIDData() throws IOException {
Set<RFIDData> dataSet = new HashSet<>();
// 创建一个缓冲区来存储接收到的数据
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
// 设置一个超时机制,避免无限等待
// 先读取一批数据到缓冲区
byte[] tempBuffer = new byte[1024];
try {
int bytesRead;
while ((bytesRead = inputStream.read(tempBuffer)) != -1) {
buffer.write(tempBuffer, 0, bytesRead); // 记录读取的数据到日志
log.info("读取到 {} 字节数据: {}", bytesRead, bytesToHex(Arrays.copyOfRange(tempBuffer, 0, bytesRead)));
// 如果读取到足够数据就停止
if (buffer.size() > 4096) {
break;
}
}
log.info("总共读取到 {} 字节数据", buffer.size());
} catch (SocketTimeoutException e) {
// 超时正常,继续处理已接收的数据
log.info("读取数据超时,继续处理已接收的数据");
}
// 处理缓冲区中的数据
byte[] receivedData = buffer.toByteArray();
int position = 0;
// 循环查找并解析所有以A0开头的数据包
while (position < receivedData.length - 2) {
// 查找A0起始字节
if (receivedData[position] == (byte) 0xA0) {
// 确保有足够的数据读取长度字节
if (position + 1 >= receivedData.length) {
break;
}
// 读取长度
int length = receivedData[position + 1] & 0xFF;
// 确保有足够的数据
if (position + 2 + length > receivedData.length) {
break;
}
// 提取数据部分
byte[] data = Arrays.copyOfRange(receivedData, position + 2, position + 2 + length);
// 解析数据
RFIDData rfidData = parseRFIDData(data);
if (rfidData != null) {
dataSet.add(rfidData);
}
// 移动到下一个数据包
position += 2 + length;
} else {
// 移动到下一个字节
position++;
}
}
return dataSet;
}
private RFIDData parseRFIDData(byte[] data) {
try {
// 检查数据长度是否足够
if (data.length < 21) { // 至少需要21个字节
return null;
}
// 检查固定值是否正确
if((data[1] & 0xFF) != 0X81){
return null;
}
// 0x01 是固定值 (data[0])
// 81 00 0C 1C 是其他数据 (data[1]-data[4])
// 接下来2个字节是PC值 (data[5], data[6])
String pc = bytesToHex(Arrays.copyOfRange(data, 5, 7));
// 接下来12个字节是EPC值 (data[7] 到 data[18])
String epc = bytesToHex(Arrays.copyOfRange(data, 7, 19));
// 接下来2个字节是CRC值 (data[19], data[20])
String crc = bytesToHex(Arrays.copyOfRange(data, 19, 21));
// 剩余字节是TID值 (data[21] 到 data[33]共12个字节)
// 确保不会越界
int tidStart = 21;
int tidEnd = tidStart + 12; // TID固定为12个字节
if (tidEnd <= data.length) {
String tid = bytesToHex(Arrays.copyOfRange(data, tidStart, tidEnd));
RFIDData rfidData = new RFIDData(pc, epc, crc, tid);
log.info("rfidData:{}", rfidData);
return rfidData;
}
// 如果没有TID数据创建一个空的TID
RFIDData rfidData = new RFIDData(pc, epc, crc, "");
log.info("rfidData:{}", rfidData);
return rfidData;
} catch (Exception e) {
log.error("解析RFID数据时出错: ", e);
return null;
}
}
private byte[] hexStringToByteArray(String hex) {
hex = hex.replaceAll(" ", ""); // 移除空格
int len = hex.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
+ Character.digit(hex.charAt(i+1), 16));
}
return data;
}
private String bytesToHex(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
sb.append(String.format("%02X", b));
}
return sb.toString();
}
public static Set<String> checkTid(String ip ,int port){
RFIDTCPClient client = new RFIDTCPClient(ip, port);
Set<RFIDData> data = new HashSet<>();
if (client.connect()) {
try {
for (int i = 0; i < 8; i++){
if (i%2==0)
client.sendHexCommand("A0 04 01 74 01 E6");
else
client.sendHexCommand("A0 04 01 74 00 E7");
client.sendHexCommand("A0 0A FF 81 02 00 06 00 00 00 00 CE");
data.addAll(client.receiveRFIDData());
}
if (data != null) {
log.info("接收到RFID数据: " + data.toString());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
client.disconnect();
}
} else {
System.out.println("连接失败");
}
Set<String> setData = data.stream().map(RFIDData::getTid).collect(Collectors.toSet());
log.info("接收到的RFID数据: " + setData);
return setData;
}
public static void main(String[] args) {
checkTid("127.0.0.1", 4002);
}
}

@ -47,26 +47,6 @@ public class RfidLiveServiceImpl extends ServiceImpl<RfidLiveMapper, RfidLive> i
@Override
public void rfidOrderStock(PlcCmdInfo plcCmdInfo, Integer times, String trayCode) {
Street street = streetService.getStreetByPlcId(plcCmdInfo.getPlcId());
RFID rfid = rfidMapper.selectOne(new QueryWrapper<RFID>().eq("street_id", street.getId()));
String tags = "";
if (times == 3) {
plcService.RFIDCheck(plcCmdInfo, false);
try {
Thread.sleep(1000 * configProperties.getRfid().getScanTime());
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
tags = String.join(",", plcService.RFIDStop(plcCmdInfo));
log.info("随行rfid扫描结果"+tags);
}
rfidRemoveLive(plcCmdInfo,street,rfid);
rfidSave( plcCmdInfo,tags,street,rfid);
}
//取货完成删除live
if (times == 2) {
rfidRemoveLive(plcCmdInfo,street,rfid);
}
}

@ -201,7 +201,7 @@ public class KsecDecoder extends DelimiterBasedFrameDecoder {
//rfid的逻辑
String code = dataInfo.getCmdName();
log.info("盘点指令:{}", ksecInfo);
plcService.check(plcCmdInfo,ksecInfo.getType(),dataInfo.getCode(),dataInfo.getTrayCode());
plcService.check(plcCmdInfo,ksecInfo.getType(),dataInfo.getLotnum(),dataInfo.getLotnum());
ksecInfo.getData().setAckStatus(1);
ctx.channel().writeAndFlush(ksecInfo);

@ -6,6 +6,8 @@ import com.zhehekeji.web.config.ConfigProperties;
import com.zhehekeji.web.service.PlcService;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
@ -13,88 +15,238 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;
@Slf4j
@Component
public class KsecNettyClient {
private static EventLoopGroup group = new NioEventLoopGroup();
@Resource
private PlcService plcService;
@Resource
private ConfigProperties configProperties;
private static Channel channel;
private EventLoopGroup group;
private volatile Channel channel;
private final AtomicBoolean isConnecting = new AtomicBoolean(false);
private final AtomicBoolean isConnected = new AtomicBoolean(false);
private final ReentrantLock connectionLock = new ReentrantLock();
// 连接配置参数
private static final int CONNECT_TIMEOUT = 5000; // 连接超时时间(毫秒)
private static final long INITIAL_RECONNECT_DELAY = 1000; // 初始重连延迟(毫秒)
private static final long MAX_RECONNECT_DELAY = 30000; // 最大重连延迟(毫秒)
private static final long RECONNECT_DELAY_MULTIPLIER = 2; // 重连延迟倍数
@PostConstruct
public void init() {
group = new NioEventLoopGroup();
log.info("KsecNettyClient 初始化完成");
// 启动后立即尝试连接
reconnect(1);
}
/**
*
* @param ksec KSEC
* @throws InterruptedException
*/
public void createClient(ConfigProperties.KSEC ksec) throws InterruptedException {
String lotnum = FileUtil.getText("lastLotnum");
if(lotnum != null){
KsecDecoder.setLastLotnum(lotnum);
if (isConnecting.get()) {
log.warn("连接已在进行中,跳过重复连接请求");
return;
}
if (StringUtils.isEmpty(ksec.getIp()) || ksec.getPort() == null) {
if (!isConnecting.compareAndSet(false, true)) {
log.warn("无法设置连接状态,可能有其他线程正在连接");
return;
}
Bootstrap client = new Bootstrap();
client.group(group);
client.channel(NioSocketChannel.class);
KsecInfo heart = KsecInfo.heart();
client.handler(new KescFilter(heart, plcService,this));
// 连接服务端
channel = client.connect(ksec.getIp(), ksec.getPort()).sync().channel();
try {
// 清理旧连接
closeChannel();
String lotnum = FileUtil.getText("lastLotnum");
if (lotnum != null) {
KsecDecoder.setLastLotnum(lotnum);
}
if (StringUtils.isEmpty(ksec.getIp()) || ksec.getPort() == null) {
log.error("无效的连接参数: IP={}, Port={}", ksec.getIp(), ksec.getPort());
throw new IllegalArgumentException("无效的连接参数");
}
Bootstrap client = new Bootstrap();
client.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, CONNECT_TIMEOUT)
.option(ChannelOption.SO_KEEPALIVE, true)
.option(ChannelOption.TCP_NODELAY, true);
KsecInfo heart = KsecInfo.heart();
client.handler(new KescFilter(heart, plcService, this));
log.info("开始连接到PLC服务器: {}:{}", ksec.getIp(), ksec.getPort());
// 异步连接并等待结果
ChannelFuture future = client.connect(ksec.getIp(), ksec.getPort()).await();
if (future.isSuccess()) {
channel = future.channel();
isConnected.set(true);
log.info("成功连接到PLC服务器: {}:{}", ksec.getIp(), ksec.getPort());
} else {
isConnected.set(false);
throw new RuntimeException("连接到PLC服务器失败", future.cause());
}
} finally {
isConnecting.set(false);
}
}
/**
* 线 RECONNECT_NUM
*
* @param upId
* 线 -
* @param upId ID
*/
public void reconnect(Integer upId) {
Boolean isConnected = false;
int num = 0;
ConfigProperties.KSEC ksec = configProperties.getKsec();
if (ksec == null) {
log.error("reconnect ,upPc is null ,id:{}", upId);
// 使用锁确保同一时间只有一个重连线程在运行
if (!connectionLock.tryLock()) {
log.debug("重连线程已在运行,跳过重复的重连请求");
return;
}
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
while ((ksec.getReconnectNum() == -1 || num < ksec.getReconnectNum() ) && !isConnected) {
ConfigProperties.KSEC ksec = configProperties.getKsec();
if (ksec == null) {
log.error("重连失败KSEC配置为空, upId: {}", upId);
// 即使配置为空也继续尝试重连
scheduleReconnect(upId, INITIAL_RECONNECT_DELAY);
return;
}
// 检查是否已经连接
if (isConnected() && channel != null && channel.isActive()) {
log.info("连接仍然有效,无需重连");
return;
}
try {
log.info("尝试连接到PLC服务器 {}:{}", ksec.getIp(), ksec.getPort());
createClient(ksec);
log.info("连接PLC服务器成功");
} catch (Exception e) {
log.error("连接PLC服务器失败: {}", e.getMessage(), e);
// 连接失败,安排下次重连
scheduleReconnect(upId, INITIAL_RECONNECT_DELAY);
}
} finally {
connectionLock.unlock();
}
}
/**
*
* @param upId ID
* @param delay ()
*/
private void scheduleReconnect(Integer upId, long delay) {
// 确保延迟不超过最大值
long actualDelay = Math.min(delay, MAX_RECONNECT_DELAY);
log.info("计划在 {} ms 后进行重连尝试", actualDelay);
// 在事件循环组中安排重连任务
group.schedule(() -> {
try {
reconnect(upId);
} catch (Exception e) {
//没连上 继续
log.error("reconnect error num:{}", num);
if(channel!= null)
channel.close();
num++;
try {
Thread.sleep(ksec.getReconnectInterval()*1000);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
log.error("调度重连任务时发生异常: {}", e.getMessage(), e);
}
}, actualDelay, TimeUnit.MILLISECONDS);
}
/**
*
* @return truefalse
*/
public boolean isConnected() {
return isConnected.get() && channel != null && channel.isActive();
}
/**
*
*/
public void closeChannel() {
if (channel != null) {
try {
if (channel.isOpen()) {
channel.close().awaitUninterruptibly();
log.info("PLC连接已关闭");
}
continue;
} catch (Exception e) {
log.warn("关闭PLC连接时发生异常: {}", e.getMessage());
} finally {
channel = null;
isConnected.set(false);
}
isConnected = true;
}
if (isConnected) {
log.info("plc reconnect success");
}
/**
* PLC
* @param ksecInfo
*/
public void write(KsecInfo ksecInfo) {
if (isConnected()) {
try {
channel.writeAndFlush(ksecInfo).addListener(future -> {
if (!future.isSuccess()) {
log.error("发送数据到PLC失败: {}", future.cause().getMessage(), future.cause());
// 发送失败可能意味着连接已断开,触发重连
handleConnectionLost();
}
});
log.debug("已发送数据到PLC服务器: {}", ksecInfo);
} catch (Exception e) {
log.error("发送数据时发生异常: {}", e.getMessage(), e);
handleConnectionLost();
}
} else {
log.error("plc reconnect error .upPcId:{},reconnect num:{},ip:{},port:{}", upId, num, ksec.getIp(), ksec.getPort());
log.error("无法发送数据PLC未连接");
handleConnectionLost();
}
}
public static void write(KsecInfo ksecInfo){
if(channel != null){
log.info("write server:"+ksecInfo);
channel.writeAndFlush(ksecInfo);
}else {
log.error(" no connected upPc");
/**
*
*/
private void handleConnectionLost() {
if (isConnected.compareAndSet(true, false)) {
log.error("检测到PLC连接丢失");
closeChannel();
// 触发重连
reconnect(1);
}
}
/**
*
*/
@PreDestroy
public void destroy() {
try {
closeChannel();
if (group != null) {
group.shutdownGracefully().awaitUninterruptibly();
log.info("Netty事件循环组已关闭");
}
} catch (Exception e) {
log.error("关闭KsecNettyClient时发生异常: {}", e.getMessage(), e);
}
}
}

Loading…
Cancel
Save