视觉服务，未完成

web/src/main/java/com/zhehekeji/web/lib/CameraDelayTask.java

@@ -1,5 +1,6 @@
 package com.zhehekeji.web.lib;
 
+import com.zhehekeji.web.service.client.TransmissionPojo;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 
@@ -15,9 +16,12 @@ public class CameraDelayTask implements Delayed {
 
    private LocalDateTime startTime;
 
+
+    private TransmissionPojo transmissionPojo;
    private LocalDateTime endTime;
 
    private String path;
+    private String command;
 
     /**
      * 0 : mp4     1:jpeg

web/src/main/java/com/zhehekeji/web/service/PlcService.java

@@ -14,11 +14,12 @@ import com.zhehekeji.web.pojo.OrderVO;
 import com.zhehekeji.web.service.RFID.RFIDMap;
 import com.zhehekeji.web.service.RFID.RFIDSocket;
 import com.zhehekeji.web.service.RFID.RFIDSocketFactory;
-import com.zhehekeji.web.service.client.ClientChanel;
-import com.zhehekeji.web.service.client.SCTransmission;
+import com.zhehekeji.web.service.client.*;
 import com.zhehekeji.web.service.damLightSource.JYDAMEquip;
 import com.zhehekeji.web.service.damLightSource.JYDamHelper;
 import com.zhehekeji.web.service.hikLightSource.HikControlSocket;
+import com.zhehekeji.web.service.ksec.KsecDataInfo;
+import com.zhehekeji.web.service.ksec.KsecInfo;
 import com.zhehekeji.web.service.ksec.KsecNettyClient;
 import com.zhehekeji.web.service.sick.SickSocket;
 import lombok.extern.slf4j.Slf4j;
@@ -38,6 +39,8 @@ import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingDeque;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 import static org.aspectj.weaver.tools.cache.SimpleCacheFactory.path;
 
@@ -642,6 +645,7 @@ public class PlcService {
 
     }
 
+    Lock lock = new ReentrantLock();
     @Resource
     private LightSourceMapper lightSourceMapper;
 
@@ -873,9 +877,65 @@ public class PlcService {
         long end = System.currentTimeMillis();
         long s = end - startTime;
         log.info("time:{}millisecond", s);
+        TransmissionPojo transmissionPojo = new TransmissionPojo(checkLog, street);
+        if (ClientChanel.get(dataInfo.getSRMNumber()) != null) {
+            ClientChanel.get(dataInfo.getSRMNumber()).writeAndFlush(transmissionPojo.toString(TransmissionType.ST));
+        } else {
+            log.error("未找到对应plc" + transmissionPojo.toString());
+        }
+        //取货完成进行拍照
+        try {
+            Thread.sleep(50L);
+            //不为其他状态进入队列
+            if (lock.tryLock()) {
+                //队列中没有任务，发送取图指令
+                //只采用队列，队列中有数据则自动发送
+                //模拟随行
+                if (configProperties.isInventorySimulationFollow() ) {
+                    TransmissionPojo transmissionPojoFollow = new TransmissionPojo(street, transmissionPojo.getRow(),transmissionPojo.getColumn(),transmissionPojo.getDirection(), "");
+                    String s = (transmissionPojoFollow).toString(TransmissionType.GPS);
+
+                    //放置到队列中，等待取图返回后删除
+                    GetPhotoDelayExecutor.addCameraDelayTask(street.getPlcId(), s, configProperties.getQueueSpanTime(),transmissionPojoFollow);
+
 
+                }
+                //放置到队列中，等待取图返回后删除
+                GetPhotoDelayExecutor.addCameraDelayTask(street.getPlcId(), transmissionPojo.toString(TransmissionType.GPS), configProperties.getQueueSpanTime(),transmissionPojo);
+            }
+
+        } catch (InterruptedException e) {
+            log.error("取图命令 error", e);
+        } finally {
+            lock.unlock();
+            log.info("盘点完成");
+        }
         return true;
     }
+
+    public KsecInfo getKsecDataInfo(TransmissionPojo transmissionPojo, String type) {
+        KsecDataInfo ksecDataInfo = new KsecDataInfo();
+        CheckLog checkLog = checkLogMapper.selectById(transmissionPojo.getCheckId());
+        if(checkLog!=null) {
+            ksecDataInfo.setLotnum(checkLog.getLotnum());
+            ksecDataInfo.setSRMNumber(transmissionPojo.getStreetNumber());
+            ksecDataInfo.setCmdName(type);
+            ksecDataInfo.setTaskId(checkLog.getTaskId().toString());
+            ksecDataInfo.setFromDirection(checkLog.getDirection());
+            ksecDataInfo.setFromColumn(checkLog.getColumn());
+            ksecDataInfo.setFromRow(checkLog.getRow());
+            ksecDataInfo.setFromSide(checkLog.getSide());
+            ksecDataInfo.setCode(checkLog.getCode());
+            ksecDataInfo.setTrayCode(checkLog.getTrayCode());
+            ksecDataInfo.setLotnum(checkLog.getLotnum());
+
+
+
+        }
+
+        KsecInfo ksecInfo = new KsecInfo("KC", "E", ksecDataInfo);
+        return ksecInfo;
+    }
     public void checkLog(Stock stock){
         CheckLog checkLog = new CheckLog();
         checkLog.setCheckNum(stock.getCheckNum());

web/src/main/java/com/zhehekeji/web/service/client/Decoder.java

@@ -1,8 +1,11 @@
 package com.zhehekeji.web.service.client;
 
-import com.zhehekeji.web.entity.Stock;
+import com.zhehekeji.web.lib.CameraDelayTask;
+import com.zhehekeji.web.service.EmptyCheckService;
 import com.zhehekeji.web.service.PlcService;
-import com.zhehekeji.web.service.ksec.*;
+import com.zhehekeji.web.service.ksec.KsecInfo;
+import com.zhehekeji.web.service.ksec.KsecNettyClient;
+import com.zhehekeji.web.service.putian.*;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
@@ -12,15 +15,10 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.nio.charset.Charset;
-import java.time.LocalDateTime;
-import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
-import static com.zhehekeji.web.service.ksec.KsecDecoder.ksecInfoMap;
-import static org.aspectj.weaver.tools.cache.SimpleCacheFactory.path;
-
 /**
  * 客户端解码器   连接用
  */
@@ -29,20 +27,32 @@ public class Decoder extends DelimiterBasedFrameDecoder {
 
     private static final Logger tcpLogger = LoggerFactory.getLogger("tcp");
 
-    public static String PT_CLIENT = "PT";
-    private static String WCS_CLIENT = "WCS";
-    private static String EMPTY_CLIENT = "EMPTY";
+    public static String START_CHECK = "ST";
+    private static String GET_PHOTO = "GP";
+    private static String GET_PHOTO_END = "GPE";
+    private static String RETURN_CHECK = "RTE";
+    private static String FOLLOW_GET_PHOTO_END = "SGPE";
+    private static String END_CHECK = "EN";
+    private static String HEART_BEAT = "HB";
+    private static String CONNECT_START = "CE";
+
+
+
+
     private static String END_STRING = "$";
 
     private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,15,30, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(20000));
 
+    private EmptyCheckService emptyCheckService;
+
     private PlcService plcService;
 
-    public Decoder(PlcService plcService) {
+    public Decoder(PlcService plcService,EmptyCheckService emptyCheckService) {
 
         super(20000,true,false, Unpooled.copiedBuffer(">".getBytes()),
                 Unpooled.copiedBuffer("$".getBytes()));
         this.plcService = plcService;
+        this.emptyCheckService = emptyCheckService;
     }
 
     @Override
@@ -53,7 +63,7 @@ public class Decoder extends DelimiterBasedFrameDecoder {
             log.debug("no data");
             return null;
         }
-        ClientRunnable clientRunnable = new ClientRunnable(in,ctx,plcService);
+        ClientRunnable clientRunnable = new ClientRunnable(in,ctx,plcService,emptyCheckService);
         threadPoolExecutor.execute(clientRunnable);
         return null;
     }
@@ -66,80 +76,66 @@ public class Decoder extends DelimiterBasedFrameDecoder {
 
         private PlcService plcService;
 
+        private EmptyCheckService emptyCheckService;
 
-        public ClientRunnable(ByteBuf in,ChannelHandlerContext ctx,PlcService plcService){
+        public ClientRunnable(ByteBuf in,ChannelHandlerContext ctx,PlcService plcService,EmptyCheckService emptyCheckService){
             this.ctx = ctx;
             this.in = in;
             this.plcService = plcService;
+            this.emptyCheckService = emptyCheckService;
         }
 
         @Override
         public void run() {
             String body = in.toString(Charset.forName("UTF-8"));
-            tcpLogger.info("receive client:{}, data length:{}",body, body.length());
-            //视觉服务
-            {
-                if(body.startsWith(HBTransmission.getHEADER())) {
-                    //心跳
-                    HBTransmission hbTransmission = new HBTransmission(body);
-                    //回复客户端心跳
-                    ctx.channel().writeAndFlush(hbTransmission.toString());
-                    ClientChanel.connect(hbTransmission.getSRMNumber(), ctx.channel());
-                    //tcpLogger.info("client:{} heart", hbTransmission.getSRMNumber());
-                    in.release();
-                } else if(body.startsWith(SCTransmission.getHeader())){
-                    //盘点指令
-                    SCTransmission scTransmission = new SCTransmission(body);
-                    if(scTransmission.isCollectOver()){
-                        //给普天发送数据采集完毕指令
-                        KsecDataInfo ksecDataInfo = ksecInfoMap.get(scTransmission.getTaskNo());
-                        ksecDataInfo.setCmdName("E2");
-                        KsecInfo ksecInfo = new KsecInfo("KC","E",ksecDataInfo);
-                        KsecNettyClient.write(ksecInfo);
-                    }else {
-                        plcService.visualInventory(scTransmission);
-
-                        KsecDataInfo ksecDataInfo = ksecInfoMap.get(scTransmission.getTaskNo());
-                        ksecDataInfo.setCmdName("E3");
-                        ksecDataInfo.setQuantity(scTransmission.getRstCount());
-                        ksecDataInfo.setTypeNum(scTransmission.getRstCategory());
-                        ksecDataInfo.setCheckRlt(Integer.parseInt(scTransmission.getCheckRst()));
-                        KsecInfo ksecInfo = new KsecInfo("KC","E",ksecDataInfo);
-                        KsecNettyClient.write(ksecInfo);
-                        ksecInfoMap.remove(scTransmission.getTaskNo());
-                        //添加到实时信息里
-                        //RealtimeCheckMap.put(scTransmission.getSRMNumber(),scTransmission.checkInfo());
-                        //更新盤點統計
-//                        emptyCheckService.updateCheckLastTime(tmTransmission.getTaskNo(),tmTransmission.getSRMNumber(),stock.getCode());
-                    }
-                    in.release();
-                }else if(body.startsWith(CETransmission.getHEADER())){
-                    //客户端建立连接
-                    CETransmission ceTransmission = new CETransmission(body);
-                    //回复客户端，建立连接完成
-
-                    ctx.channel().writeAndFlush(ceTransmission.toString());
-                    ClientChanel.connect(ceTransmission.getSRMNumber(), ctx.channel());
-                    tcpLogger.info("client:{} connect", ceTransmission.getSRMNumber());
-                    in.release();
+            tcpLogger.info("receive client:{}, data length:{}", body, body.length());
+            TransmissionPojo transmissionPojo = new TransmissionPojo(body);
+            //心跳进行连接
+            if(HEART_BEAT.equals(transmissionPojo.getHeader()) || CONNECT_START.equals(transmissionPojo.getHeader())){
+                ClientChanel.connect(transmissionPojo.getStreetNumber(),ctx.channel());
+            }
+            //获取照片后发送进行计算逻辑，并在拍照队列中取出拍照发送
+            else if(GET_PHOTO_END.equals(transmissionPojo.getHeader())){
+                if(transmissionPojo.getTaskId() != null && !"0".equals(transmissionPojo.getTaskId())) {
+                    ClientChanel.get(transmissionPojo.getStreetNumber()).writeAndFlush(transmissionPojo.toString(TransmissionType.RTS));
+
+                   // GetPhotoDelayExecutor.addCameraDelayTask(transmissionPojo.getStreetNumber(), transmissionPojo.toString(TransmissionType.RTS), 3000);
                 }
-                else if(body.startsWith("DC")){
-                    //客户端断开连接
-                    String [] strings = body.split("&");
-                    if(strings != null && strings.length == 2){
-                        tcpLogger.info("client:{} disConnect", strings[1]);
-                        ClientChanel.disConnect(strings[1]);
-                    }
-                    in.release();
+                try {
+                    Thread.sleep(50L);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+                //删除队列的拍照数据
+                GetPhotoDelayExecutor.remove(transmissionPojo.getStreetNumber(),transmissionPojo);
+                //读取下一个发送
+                CameraDelayTask cameraDelayTask =  GetPhotoDelayExecutor.nextOne(transmissionPojo.getStreetNumber(),transmissionPojo.toString(TransmissionType.GPS));
+                if (cameraDelayTask != null) {
+                    TransmissionPojo pojo = new TransmissionPojo(cameraDelayTask.getCommand());
+                    ClientChanel.get(pojo.getStreetNumber()).writeAndFlush(pojo.toString(TransmissionType.GPS));
                 }
 
-//                else if (body.contains("EMPTY_CLIENT")){
-//                    ClientChanel.connect(EMPTY_CLIENT_NAME, ctx.channel());
-//                    tcpLogger.info("client:{} connect", EMPTY_CLIENT_NAME);
-//                    in.release();
-//                }
+            }
+            //照片和结果保存，并发送给上位机
+            else if(RETURN_CHECK.equals(transmissionPojo.getHeader())){
+               //保存数据
+                plcService.visualCalculationResults(transmissionPojo);
+                //发送给上位机
+                KsecInfo ksecInfo = plcService.getKsecDataInfo(transmissionPojo,"E");
+                ksecInfo.getData().setTypeNum(transmissionPojo.getCategory());
+                ksecInfo.getData().setQuantity(transmissionPojo.getCount());
+                ksecInfo.getData().setCheckRlt(transmissionPojo.getResult());
+                KsecNettyClient.write(ksecInfo);
+                GetPhotoDelayExecutor.removeTask(transmissionPojo.getStreetNumber(),  transmissionPojo);
+
+
+
+            }
+            //照片和结果保存，并发送给上位机
+            else if(FOLLOW_GET_PHOTO_END.equals(transmissionPojo.getHeader())){
+                //保存数据
+                plcService.saveFollowPhoto(transmissionPojo);
             }
         }
     }
-
 }

web/src/main/java/com/zhehekeji/web/service/client/GetPhotoDelayExecutor.java

@@ -0,0 +1,207 @@
+package com.zhehekeji.web.service.client;
+
+import com.zhehekeji.common.util.SpringContextUtil;
+import com.zhehekeji.web.entity.Street;
+import com.zhehekeji.web.lib.CameraDelayTask;
+import com.zhehekeji.web.service.PlcService;
+import com.zhehekeji.web.service.ksec.KsecInfo;
+import com.zhehekeji.web.service.ksec.KsecNettyClient;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.DelayQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+/**
+ * GetPhotoDelayExecutor类用于管理照片获取的延时任务。
+ */
+@Slf4j
+public class GetPhotoDelayExecutor {
+    // 延时队列，存放CameraDelayTask任务
+    public static Map<String, DelayQueue<CameraDelayTask>> cameraDelayTaskMap = new ConcurrentHashMap<>();
+    // 线程池，用于执行延时任务
+    public static DelayQueue<CameraDelayTask> delayTasks = new DelayQueue<>();
+    private static ExecutorService exec = Executors.newFixedThreadPool(15);
+
+    /**
+     * 向延时队列中添加一个拍照延时任务。
+     *
+     * @param plcId 相机的PLC编号
+     * @param getPhotoCommand 获取照片的命令
+     * @param time 任务延时时间
+     */
+    public static void addCameraDelayTask(String plcId, String getPhotoCommand, long time,TransmissionPojo transmissionPojo) {
+        // 如果队列为空，则直接发送命令
+        if(cameraDelayTaskMap.get(plcId)==null || cameraDelayTaskMap.get(plcId).size() == 0) {
+            if( ClientChanel.get(plcId) != null){
+                log.info("队列中无数据，输出"+getPhotoCommand);
+                ClientChanel.get(plcId).writeAndFlush(getPhotoCommand);
+            }else {
+
+                log.info("队列中无数据，未找到通信"+plcId);
+            }
+        }
+        // 创建一个CameraDelayTask对象，并将其添加到队列中
+        CameraDelayTask cameraDelayTask = new CameraDelayTask(plcId, getPhotoCommand, time,transmissionPojo);
+        if(cameraDelayTaskMap.get(plcId)!=null){
+
+            cameraDelayTaskMap.get(plcId).add(cameraDelayTask);
+        }else {
+            cameraDelayTaskMap.put(plcId,new DelayQueue<>());
+            cameraDelayTaskMap.get(plcId).add(cameraDelayTask);
+        }
+        delayTasks.add(cameraDelayTask);
+    }
+
+    /**
+     * 根据命令和相机PLC编号从延时队列中移除任务。
+     *
+     * @param plcId 命令行
+     */
+    public static CameraDelayTask remove(String  plcId, TransmissionPojo transmissionPojo) {
+        synchronized (plcId) {
+            // 将延时队列中的任务转换为数组，便于遍历和移除
+            Object[] objects = cameraDelayTaskMap.get(plcId).toArray();
+            if(objects.length > 0) {
+                for(Object object : objects){
+
+                    CameraDelayTask cameraDelayTask = (CameraDelayTask)object;
+                    if (cameraDelayTask != null
+                            && cameraDelayTask.getTransmissionPojo().getTaskId().equals(transmissionPojo.getTaskId())
+                            && cameraDelayTask.getTransmissionPojo().getCheckId().equals(transmissionPojo.getCheckId())
+                            && cameraDelayTask.getTransmissionPojo().getDirection().equals(transmissionPojo.getDirection())) {
+                        cameraDelayTaskMap.get(plcId).remove(cameraDelayTask);
+                        return cameraDelayTask;
+
+                    }
+                }
+
+
+            }
+        }
+        return null;
+    }
+    public static CameraDelayTask removeTask(String  plcId, TransmissionPojo transmissionPojo) {
+        synchronized (plcId){
+            // 将延时队列中的任务转换为数组，便于遍历和移除
+            Object[] objects = delayTasks.toArray();
+            if(objects.length > 0) {
+                for(Object object : objects){
+
+                    CameraDelayTask cameraDelayTask = (CameraDelayTask)object;
+                    if (cameraDelayTask != null
+                            && cameraDelayTask.getTransmissionPojo().getTaskId().equals(transmissionPojo.getTaskId())
+                            && cameraDelayTask.getTransmissionPojo().getCheckId().equals(transmissionPojo.getCheckId())
+                            && cameraDelayTask.getTransmissionPojo().getDirection().equals(transmissionPojo.getDirection())) {
+                        delayTasks.remove(cameraDelayTask);
+                        return cameraDelayTask;
+
+                    }
+                }
+
+
+            }
+        }
+        return null;
+    }
+
+    public static CameraDelayTask nextOne(String  plcId, String getPhotoCommand) {
+        plcId = plcId.intern();
+        synchronized (plcId) {
+            // 将延时队列中的任务转换为数组，便于遍历和移除
+            Object[] objects = cameraDelayTaskMap.get(plcId).toArray();
+            if(objects.length > 0) {
+                CameraDelayTask cameraDelayTask = (CameraDelayTask)objects[0];
+                if (cameraDelayTask != null) {
+                    return cameraDelayTask;
+
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 启动延时任务的执行器。
+     */
+    public static void runExecutor(List<Street> streets ) {
+        for (Street street: streets){
+
+            exec.execute(new Consumer(street));
+        }
+        exec.execute(new TaskConsumer());
+    }
+
+    /**
+     * Consumer内部类，实现Runnable接口，用于消费延时队列中的任务。
+     */
+    private static class Consumer implements Runnable {
+        private Street street;
+        Consumer(Street street){
+            this.street = street;
+        }
+        /**
+         * 无限循环，不断从延时队列中取出任务并执行。
+         */
+        @Override
+        public void run() {
+            while (true) {
+                try {
+                    // 从Spring上下文中获取PlcService实例
+                    PlcService plcService = SpringContextUtil.getBean(PlcService.class);
+                    // 从延时队列中获取并移除一个任务
+                    if (cameraDelayTaskMap.get(street.getPlcId())!=null) {
+                        CameraDelayTask cameraDelayTask = cameraDelayTaskMap.get(street.getPlcId()).take();
+//                        if (cameraDelayTask != null) {
+//                            // 构造传输对象，并将任务命令等信息设置进去
+//                            TransmissionPojo transmissionPojo = new TransmissionPojo(cameraDelayTask.getCommand());
+//                            // 调用PLC服务，模拟发送数据到上位机
+//                            KsecInfo ksecInfo = plcService.getKsecDataInfo(transmissionPojo, "E");
+//                            ksecInfo.getData().setTypeNum(transmissionPojo.getCategory());
+//                            ksecInfo.getData().setQuantity(transmissionPojo.getCount());
+//                            ksecInfo.getData().setCheckRlt(0);
+//                            // 将信息发送给上位机
+//                            if (!transmissionPojo.getTaskId().equals("0"))
+//                                KsecNettyClient.write(ksecInfo);
+//                        }
+                    }
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+    private static class TaskConsumer implements Runnable {
+
+        /**
+         * 无限循环，不断从延时队列中取出任务并执行。
+         */
+        @Override
+        public void run() {
+            while (true) {
+                try {
+                    // 从Spring上下文中获取PlcService实例
+                    PlcService plcService = SpringContextUtil.getBean(PlcService.class);
+                    // 从延时队列中获取并移除一个任务
+                        CameraDelayTask cameraDelayTask = delayTasks.take();
+                        if (cameraDelayTask != null) {
+                            // 构造传输对象，并将任务命令等信息设置进去
+                            TransmissionPojo transmissionPojo = new TransmissionPojo(cameraDelayTask.getCommand());
+                            // 调用PLC服务，模拟发送数据到上位机
+                            KsecInfo ksecInfo = plcService.getKsecDataInfo(transmissionPojo, "E");
+                            ksecInfo.getData().setTypeNum(transmissionPojo.getCategory());
+                            ksecInfo.getData().setQuantity(transmissionPojo.getCount());
+                            ksecInfo.getData().setCheckRlt(0);
+                            // 将信息发送给上位机
+                            if (!transmissionPojo.getTaskId().equals("0"))
+                                KsecNettyClient.write(ksecInfo);
+                        }
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+}

web/src/main/java/com/zhehekeji/web/service/client/NettyServer.java

@@ -1,5 +1,6 @@
 package com.zhehekeji.web.service.client;
 
+import com.zhehekeji.web.service.EmptyCheckService;
 import com.zhehekeji.web.service.PlcService;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelFuture;
@@ -19,6 +20,8 @@ public class NettyServer {
     @Resource
     private PlcService plcService;
 
+    @Resource
+    private EmptyCheckService emptyCheckService;
 
     public void CreateNettyServer(int port) throws InterruptedException {
         Thread thread = new Thread(new Runnable() {
@@ -39,7 +42,7 @@ public class NettyServer {
                                 @Override
                                 public void initChannel(SocketChannel ch) {
                                     ch.pipeline().addLast(new NettyConnectHandler());
-                                    ch.pipeline().addLast(new Decoder(plcService));
+                                    ch.pipeline().addLast(new Decoder(plcService,emptyCheckService));
                                     ch.pipeline().addLast(new Encoder());
                                 }}); // 子处理器，用于处理workerGroup
 

web/src/main/java/com/zhehekeji/web/service/client/TransmissionPojo.java

@@ -0,0 +1,164 @@
+package com.zhehekeji.web.service.client;
+
+import com.zhehekeji.web.entity.CheckLog;
+import com.zhehekeji.web.entity.Street;
+import lombok.Data;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+@Data
+public class TransmissionPojo {
+    private String data;
+    private String[] dataArray;
+    private String header;
+    private String streetNumber;//巷道标识符
+
+    private Integer row;//行
+    private Integer column;//列
+
+    private String pcd;//点位文件路径
+    private String taskId;
+    private String checkId;
+    private Integer direction;//左右
+    private Integer count = 0; //数量
+    private String category = ""; //品规
+    private Set<String> picsPath; //照片
+
+
+    private Integer result;
+    public TransmissionPojo(CheckLog checkLog , Street street){
+        this.checkId = checkLog.getId().toString();
+        this.streetNumber = street.getPlcId();
+        this.taskId = checkLog.getLotnum();
+        this.row = checkLog.getRow();
+        this.column = checkLog.getColumn();
+        this.direction = checkLog.getDirection();
+        this.count = checkLog.getCount();
+        if(checkLog.getCategory() != null && checkLog.getCategory().contains("/")) {
+            this.category = checkLog.getCategory().split("/")[0];
+        }else {
+            this.category = checkLog.getCategory();
+        }
+
+    }
+
+    /**
+     * 将给定数字转换为指定长度（默认3位）的字符，不足部分用“0”补全。
+     *
+     * @param number 需要转换的数字
+     * @param length 目标字符长度（默认3）
+     * @return 符合要求的字符串
+     */
+    public static String convertNumberToFixedLengthChars(int number, int length) {
+        if (length < 1) {
+            throw new IllegalArgumentException("Length must be a positive integer.");
+        }
+
+        String numStr = Integer.toString(number);
+        while (numStr.length() < length) {
+            numStr = "0" + numStr;
+        }
+        return numStr;
+    }
+    public TransmissionPojo( Street street,Integer row , Integer column,Integer direction,String orderId){
+        this.streetNumber = street.getPlcId();
+        this.row = row;
+
+        this.taskId = "0";
+        this.direction = direction;
+        this.column = column;
+        this.checkId =  convertNumberToFixedLengthChars(row, 3) + convertNumberToFixedLengthChars(column, 3);
+
+    }
+    public String toString(TransmissionType type) {
+        this.header = type.toString();
+        if (type == TransmissionType.ST) {
+            return "ST&" + streetNumber + "&" + checkId + "&" + taskId + "&" + direction ;
+        }else if (type == TransmissionType.GPS) {
+            return "GPS&" + streetNumber +"/"+row +"/"+column+ "&" + checkId + "&" + taskId + "&" + direction+ "&" + category + "&" + count;
+        }else if (type == TransmissionType.RTS) {
+            return "RTS&" +  streetNumber +"/"+row +"/"+column+  "&" + checkId + "&" + taskId + "&" + direction  + "&" + category + "&" + count;
+        }
+        return "";
+    }
+
+    public TransmissionPojo(String data) {
+        this.data = data;
+        data = data.replace(">", "");
+        this.dataArray = data.split("&");
+        this.header = dataArray[0];
+        if(dataArray[1].contains("/")) {
+            String[] dataArr = dataArray[1].split("/");
+            this.streetNumber = dataArr[0];
+            this.row = Integer.valueOf(dataArr[1]);
+            if(dataArr.length > 2) {
+                this.column = Integer.valueOf(dataArr[2]);
+            }
+        }else {
+            this.streetNumber = dataArray[1];
+        }
+        if (dataArray.length > 2) {
+            this.checkId = dataArray[2];
+            this.taskId = (dataArray[3]);
+            if(dataArray[4] != null && !"".equals(dataArray[4]) && !"null".equals(dataArray[4])) {
+                this.direction = Integer.valueOf(dataArray[4]);
+            }
+        }
+
+        if (dataArray.length > 5) {
+            if(dataArray[5] != null &&!"".equals(dataArray[5]) &&  !"null".equals(dataArray[5]) ) {
+
+                this.category = dataArray[5];
+            }
+            if( dataArray.length > 6 && dataArray[6] != null && !"".equals(dataArray[6]) && ! "null".equals(dataArray[5])) {
+                this.count = Integer.valueOf(dataArray[6]);
+            }
+        }
+        if (dataArray.length > 7) {
+            this.result = Integer.parseInt(dataArray[7])==0 ?0:1;
+            //不记录2d图像
+            //String path2D = "/fileData/"+this.taskId+"/"+this.checkId+"/"+this.direction+".jpg";
+
+            String path3D ;
+            if((this.taskId!=null) && !"".equals(this.taskId)){
+                path3D = "/fileData/"+this.taskId+"/"+this.checkId+"/"+(this.direction+2)+".PNG";
+            }else {
+                path3D = "/fileData/"+this.checkId+"/"+(this.direction+2)+".PNG";
+            }
+            Set<String> strings = new HashSet<>();
+            //strings.add(path2D);
+            strings.add(path3D);
+
+            // 将数组中的元素添加到 Set 集合中
+            if(dataArray.length > 8 && dataArray[8].split(";").length>0) {
+                String[] s =  dataArray[8].split(";");
+                for (int i = 0; i < s.length; i++) {
+                    s[i] = s[i].replace("\\\\","/");
+                    s[i] = s[i].replace("\\","/");
+                    if(s[i].startsWith(".")) {
+                        s[i] = s[i].replaceFirst(".", ""); // 移除单个字符
+                    }
+
+                    // 或者
+                    // stringArray[i] = stringArray[i].replaceAll(regexToRemove, ""); // 使用正则表达式移除字符类别
+                }
+                Collections.addAll(strings,s);
+                strings.remove("");
+            }
+            this.picsPath = strings;
+
+        }
+        if(this.taskId != null && !"".equals(this.taskId) && this.checkId != null && !"".equals(this.checkId))
+            this.pcd = "/fileData/"+this.taskId+"/"+this.checkId+"/"+(this.direction+2)+".pcd";
+
+    }
+
+    public static void main(String[] args) {
+        //2024-05-31 17:52:07,909 INFO (Decoder.java:96)- receive client:RTE&001/1/9&2812&&2&0341&30&1&.\fileData\\2812\4.PNG;\fileData\\2812\2_0341_rlt.jpg&.\fileData\\2812\4.pcd, data length:106
+        TransmissionPojo transmissionPojo = new TransmissionPojo("RTE&001/1/9&2812&&2&0341&30&1&.\\fileData\\\\2812\\4.PNG;\\fileData\\\\2812\\2_0341_rlt.jpg&.\\fileData\\\\2812\\4.pcd>");
+        System.out.println(transmissionPojo);
+    }
+
+}

web/src/main/java/com/zhehekeji/web/service/client/TransmissionType.java

@@ -0,0 +1,14 @@
+package com.zhehekeji.web.service.client;
+
+public enum TransmissionType {
+    ST   ,
+    GPS  ,
+    GPE  ,
+    SGPS  ,
+    SGPE  ,
+    RTS  ,
+    RTE   ,
+    EN   ,
+    ZHB  ;
+
+}