#输送线循环BUG修复

lty

2025-03-27 9540c4904147cb4baf037892447d6f85dc004646

#输送线循环BUG修复

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -158,10 +158,30 @@
                        if (staProtocol.getSiteId() == 107 || staProtocol.getSiteId() == 109) {
                            StaProtocol staProtocol5 = getClonedStation(devpThread, staProtocol.getSiteId() - 1);
                            if (staProtocol5 != null && (staProtocol5.isLoading() && (staProtocol5.getStaNo() == 107 || staProtocol5.getStaNo() == 109))) {
                                short workNo = staProtocol5.getWorkNo();

                                // **先清零，等待 100ms**
                                staProtocol5.setWorkNo((short) 0);
                                staProtocol5.setStaNo((short) 0);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol5));
                                Thread.sleep(100);

                                // **再写入目标值**
                                staProtocol5.setWorkNo(workNo);
                                staProtocol5.setStaNo((short) 112);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol5));
                            }
                        } else {
                            short workNo = staProtocol.getWorkNo();

                            // **先清零，等待 100ms**
                            staProtocol.setWorkNo((short) 0);
                            staProtocol.setStaNo((short) 0);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            Thread.sleep(100);

                            // **再写入目标值**
                            staProtocol.setWorkNo(workNo);
                            staProtocol.setStaNo((short) 112);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        }
@@ -181,35 +201,50 @@
        return (staProtocol != null) ? staProtocol.clone() : null;
    }

    //112循环站点至出库站
    public synchronized void shiftCyclePointToTarget() throws IOException, InterruptedException{
        try{
    // 112循环站点至出库站
    public synchronized void shiftCyclePointToTarget() throws IOException, InterruptedException {
        try {
            for (DevpSlave devp : slaveProperties.getDevp()) {
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                if (devpThread == null) {
                    continue;
                }

                StaProtocol staProtocol = devpThread.getStation().get(112);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if(staProtocol.getWorkNo() == 0){
                if (staProtocol == null || staProtocol.getWorkNo() == 0) {
                    continue;
                }

                // 查询任务信息
                TaskWrk taskWrk = taskWrkMapper.selectStaWorking(Integer.valueOf(staProtocol.getWorkNo()));
                if(taskWrk != null &&  taskWrk.getWrkNo() < 9001 && taskWrk.getWrkNo() > 6000){
                    staProtocol.setStaNo(Short.valueOf(taskWrk.getTargetPoint()));
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                if (taskWrk == null || taskWrk.getWrkNo() < 6001 || taskWrk.getWrkNo() > 9000) {
                    continue;
                }

                // 先清零
                short workNo = staProtocol.getWorkNo();
                short oldStaNo = staProtocol.getStaNo();
                staProtocol.setWorkNo((short) 0);
                staProtocol.setStaNo((short) 0);
                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                Thread.sleep(100); // 让 PLC 识别变化

                // 再写入目标站点
                staProtocol.setWorkNo(workNo);
                staProtocol.setStaNo(Short.valueOf(taskWrk.getTargetPoint()));
                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                log.info("Shifted from cycle station 112 to target {}, workNo: {}", taskWrk.getTargetPoint(), workNo);
            }
        }catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        } catch (Exception e) {
            log.error("shiftCyclePointToTarget error", e);
        }
    }





    public synchronized void generateStoreWrkFile1() throws IOException, InterruptedException {
        try {
            // 根据输送线plc遍历

 src/main/java/com/zy/core/cache/MessageQueue.java

@@ -150,5 +150,20 @@
                break;
        }
    }
    public static boolean offer(SlaveType type, Integer devpId, Task task, Runnable callback) {
        boolean result = offer(type, devpId, task); // 先执行原有任务逻辑
        if (result && callback != null) {
            new Thread(() -> {
                try {
                    Thread.sleep(200); // 模拟任务执行时间
                    callback.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
        return result;
    }


}

 src/main/java/com/zy/core/thread/SiemensDevpThread.java

@@ -493,78 +493,117 @@

    }
    private void write(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
        if (staProtocol == null) {
            return;
        }
        ArrayList<Integer> staNos = getStaNo();

        ArrayList<Integer> staNos = getStaNo();
        int index = staNos.indexOf(staProtocol.getSiteId());

        OperateResult writeResult;
        //任务下发次数
        int writeCount = 0;
        //任务下发成功标识
        boolean writeFlag = false;
        while(writeCount < 5){
            OperateResult writeResult1 = siemensS7Net.Write("DB100." + index*6,  staProtocol.getWorkNo().intValue());    // 工作号
            OperateResult writeResult2 = siemensS7Net.Write("DB100." + (index*6+4), staProtocol.getStaNo());    // 目标站
            if(writeResult1.IsSuccess && writeResult2.IsSuccess){
                Thread.sleep(200);
                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*6, (short)6);
                if(readResult.IsSuccess){
                    Integer workNo = siemensS7Net.getByteTransform().TransInt32(readResult.Content, 0);
                    short staNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 4);
                    if(workNo.equals(staProtocol.getWorkNo().intValue()) && staProtocol.getStaNo().equals(staNo)){
                        //任务命令写入成功
                        writeFlag = true;
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        break;
                    } else {//返回结果是成功了，但是真实值不相同
                        writeCount++;
                        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={1}，站点数据={2},写入次数={3}",
                                slave.getId(), JSON.toJSON(staProtocol),writeCount));
                        log.error("写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                    }
                } else {
                    writeCount++;
                    OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令后读取失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                            slave.getId(), JSON.toJSON(staProtocol), writeCount));
                    log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
        if (index == -1) {
            log.error("站点编号 {} 不在已知列表中，无法写入任务！", staProtocol.getSiteId());
            return;
        }

        int writeCount = 0; // 任务下发尝试次数
        boolean writeFlag = false; // 任务下发成功标记
        String plcAddressWorkNo = "DB100." + index * 6;
        String plcAddressStaNo = "DB100." + (index * 6 + 4);

        while (writeCount < 5) {
            // **读取当前PLC状态，避免不必要的写入**
            OperateResultExOne<byte[]> readResult = siemensS7Net.Read(plcAddressWorkNo, (short) 6);
            if (readResult.IsSuccess) {
                int currentWorkNo = siemensS7Net.getByteTransform().TransInt32(readResult.Content, 0);
                short currentStaNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 4);

                if (currentWorkNo == staProtocol.getWorkNo().intValue() && currentStaNo == staProtocol.getStaNo()) {
                    log.info("站点 {} 当前状态已匹配，无需重复写入", staProtocol.getSiteId());
                    return;
                }
            } else {
            }

            // **清零并确认**
            if (!clearPLCData(plcAddressWorkNo, plcAddressStaNo, staProtocol.getSiteId())) {
                writeCount++;
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                        slave.getId(), JSON.toJSON(staProtocol),writeCount));
                log.error("写入输送线命令失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                continue; // 重新尝试清零
            }
            Thread.sleep(200);

            // **写入新任务**
            if (writeTaskToPLC(plcAddressWorkNo, plcAddressStaNo, staProtocol)) {
                writeFlag = true;
                log.info("输送线命令写入成功，PLC编号={}，站点数据={}，尝试次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                break;
            }

            log.warn("输送线命令写入失败，PLC编号={}，站点数据={}，尝试次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
            writeCount++;
        }

        //写命令尝试了5次还是失败了
        if(!writeFlag){
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令尝试5次失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            log.error("写入输送线命令尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));

//            //重新添加数据到任务队列
//            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
//            read();//读取1次设备状态
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发成功 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
            log.info("输送线命令下发 [id:{}] >>>>> 命令下发成功： {}",  slave.getId(), JSON.toJSON(staProtocol));

//            Integer siteId = staProtocol.getSiteId();
//            staProtocol = station.get(siteId);
//            if ((siteId == 101 || siteId == 201)&&(staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0)) {
//                staProtocol.setPakMk(true);
//            }
        }


        // **写入失败处理**
        handleWriteFailure(staProtocol, writeFlag);
    }

    /**
     * 清零 PLC 数据并验证清零是否成功
     */
    private boolean clearPLCData(String plcAddressWorkNo, String plcAddressStaNo, int siteId) throws InterruptedException {
        siemensS7Net.Write(plcAddressWorkNo, 0);
        siemensS7Net.Write(plcAddressStaNo, (short) 0);
        Thread.sleep(100); // 等待PLC识别

        OperateResultExOne<byte[]> readResult = siemensS7Net.Read(plcAddressWorkNo, (short) 6);
        if (readResult.IsSuccess) {
            int readWorkNo = siemensS7Net.getByteTransform().TransInt32(readResult.Content, 0);
            short readStaNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 4);
            if (readWorkNo == 0 && readStaNo == 0) {
                return true; // 清零成功
            }
        }

        log.warn("站点 {} 清零失败，尝试重新清零...", siteId);
        return false;
    }

    /**
     * 写入新任务到 PLC 并验证是否成功
     */
    private boolean writeTaskToPLC(String plcAddressWorkNo, String plcAddressStaNo, StaProtocol staProtocol) throws InterruptedException {
        OperateResult writeResult1 = siemensS7Net.Write(plcAddressWorkNo, staProtocol.getWorkNo().intValue());
        OperateResult writeResult2 = siemensS7Net.Write(plcAddressStaNo, staProtocol.getStaNo());

        if (writeResult1.IsSuccess && writeResult2.IsSuccess) {
            Thread.sleep(200); // 等待 PLC 识别新值
            OperateResultExOne<byte[]> readResult = siemensS7Net.Read(plcAddressWorkNo, (short) 6);
            if (readResult.IsSuccess) {
                int workNo = siemensS7Net.getByteTransform().TransInt32(readResult.Content, 0);
                short staNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 4);
                return workNo == staProtocol.getWorkNo().intValue() && staNo == staProtocol.getStaNo();
            }
        }
        return false;
    }

    /**
     * 处理写入失败的情况
     */
    private void handleWriteFailure(StaProtocol staProtocol, boolean writeFlag) {
        if (!writeFlag) {
            StaProtocol currentStaProtocol = station.get(staProtocol.getSiteId());
            if (currentStaProtocol.getWorkNo() == 0 && currentStaProtocol.getStaNo() == 0) {
                currentStaProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线命令尝试5次失败。PLC编号={1}，站点数据={2}",
                    slave.getId(), JSON.toJSON(currentStaProtocol)));
            log.error("输送线命令尝试5次失败，PLC编号={}，站点数据={}", slave.getId(), JSON.toJSON(currentStaProtocol));
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线命令成功 [id:{1}] >>>>> {2}",
                    DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
            log.info("输送线命令成功 [id:{}] >>>>> {}", slave.getId(), JSON.toJSON(staProtocol));
        }
    }


    private void write2(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;

 src/main/resources/application.yml

@@ -8,7 +8,7 @@
    name: @pom.build.finalName@
  datasource:
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    url: jdbc:sqlserver://127.0.0.1:1433;databasename=rywxasrs
    url: jdbc:sqlserver://10.10.10.220:1433;databasename=rywxasrs
    username: sa
    password: sa@123
  mvc: