Merge remote-tracking branch 'origin/jxjdzwcs' into jxjdzwcs

野心家

2025-04-01 66942458f7753fe4ddee7c5ed3386d61cff28b24

Merge remote-tracking branch 'origin/jxjdzwcs' into jxjdzwcs

# Conflicts:
#	src/main/java/com/zy/core/thread/SiemensCrnThread.java

 pom.xml

@@ -15,7 +15,7 @@

    <properties>
        <java.version>1.8</java.version>
        <cool.version>3.2.0</cool.version>
        <cool.version>3.4.5</cool.version>
        <mysql-driver.version>5.1.47</mysql-driver.version>
        <mybatis-plus.version>2.3.2</mybatis-plus.version>
        <fastjson.version>1.2.58</fastjson.version>

 src/main/java/com/zy/asrs/controller/CrnController.java

@@ -391,7 +391,7 @@
        command.setDestinationPosX(param.getRow());     // 目标库位排
        command.setDestinationPosY(param.getBay());     // 目标库位列
        command.setDestinationPosZ(param.getLev());     // 目标库位层
        command.setCommand((short)1);
//        command.setCommand((short)1);
        return crnControl(command)?R.ok():R.error();
    }

@@ -413,7 +413,7 @@
        command.setDestinationPosX(param.getRow());     // 目标库位排
        command.setDestinationPosY(param.getBay());     // 目标库位列
        command.setDestinationPosZ(param.getLev());     // 目标库位层
        command.setCommand((short)1);
//        command.setCommand((short)1);
        return crnControl(command)?R.ok():R.error();
    }

@@ -435,7 +435,7 @@
        command.setDestinationPosZ(param.getRow());     // 目标库位排
        command.setDestinationPosX(param.getBay());     // 目标库位列
        command.setDestinationPosY(param.getLev());     // 目标库位层
        command.setCommand((short)1);
//        command.setCommand((short)1);
        LocMast sourceLoc = locMastService.selectOne(new EntityWrapper<LocMast>().eq("row1", command.getSourcePosX())
                .eq("bay1", command.getSourcePosY()).eq("lev1", command.getSourcePosZ()));
        LocMast loc = locMastService.selectOne(new EntityWrapper<LocMast>().eq("row1", command.getDestinationPosX())

 src/main/java/com/zy/asrs/mapper/TaskWrkMapper.java

@@ -40,4 +40,6 @@

    List<TaskWrk> selectWorkingTask();//获取工作中的任务

    TaskWrk selectStaWorking(Integer wrkNo);

}

 src/main/java/com/zy/asrs/service/BasDevpService.java

@@ -44,4 +44,7 @@
     */
    BasDevp checkSiteStatus(Integer devpNo, boolean put);

    int getStoreCount();


}

 src/main/java/com/zy/asrs/service/TaskWrkService.java

@@ -29,5 +29,10 @@
    List<TaskWrk> selectToBeHistoryData();

    int saveToHistory(String taskNo);//将任务转历史日志
    /**
     * 获取对应堆垛机号工作状态为14，12，2的工作档
     */
    int getStoreCount(Integer crnNo);

    TaskWrk selectStaWorking(Integer wrkNo);
}

 src/main/java/com/zy/asrs/service/WrkMastService.java

@@ -15,4 +15,9 @@

    int getOutToStn182(Integer devpNo);

    /**
     * 获取对应堆垛机号工作状态为14，12，2的工作档
     */
    int getStoreCount(Integer crnNo);

}

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

@@ -6,13 +6,19 @@
import com.zy.asrs.entity.BasCrnp;
import com.zy.asrs.mapper.BasCrnpMapper;
import com.zy.asrs.service.BasCrnpService;
import com.zy.asrs.service.WrkMastService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Slf4j
@Service("basCrnpService")
public class BasCrnpServiceImpl extends ServiceImpl<BasCrnpMapper, BasCrnp> implements BasCrnpService {

    @Value("${wms.count}")
    private Integer maxCount;
    @Autowired
    private WrkMastService wrkMastService;
    @Override
    public BasCrnp checkSiteStatus(Integer crnId) {
        BasCrnp crnp = this.selectById(crnId);
@@ -36,6 +42,11 @@
            return false;
        }
        if (pakin) {
//            int storeCount = wrkMastService.getStoreCount(crnNo);
//            if(storeCount >= maxCount){
//                log.error("{}号堆垛机暂存数已满!", crnNo);
//                return false;
//            }
            if ("N".equals(crnp.getInEnable())) {
                log.error("{}号堆垛机不可入", crnNo);
                return false;
@@ -60,4 +71,5 @@
//        }
        return true;
    }

}

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

@@ -1,8 +1,10 @@
package com.zy.asrs.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.core.exception.CoolException;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.TaskWrk;
import com.zy.asrs.mapper.BasDevpMapper;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.WrkMastService;
@@ -64,4 +66,9 @@
        }
        return station;
    }

    @Override
    public int getStoreCount() {
        return baseMapper.selectCount(new EntityWrapper<BasDevp>().in("loading","Y"));
    }
}

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

@@ -39,15 +39,18 @@
import com.zy.core.thread.SiemensDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.CompletableFuture;

/**
 * 立体仓库WCS系统主流程业务
@@ -94,7 +97,10 @@
    private ApiLogService apiLogService;
    @Autowired
    private CommonService commonService;

    @Value("${wms.count}")
    private Integer maxCount;
    @Autowired
    private WrkMastService wrkMastService;
    @Value("${wms.url}")
    private String wmsUrl;
    @Value("${wms.inboundTaskApplyPath}")
@@ -107,6 +113,115 @@
    private CrnController crnController;
    @Autowired
    private SiteController siteController;
    @Synchronized
    public void shiftTargetToCyclePoint() throws IOException, InterruptedException {
        try {
            for (DevpSlave devp : slaveProperties.getDevp()) {
                for (DevpSlave.Sta outSta : devp.getOutSta()) {
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    if (devpThread == null) {
                        continue;
                    }

                    StaProtocol staProtocol = getClonedStation(devpThread, outSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    }

                    // 获取其他相关站点
                    StaProtocol staProtocol1 = getClonedStation(devpThread, 1001);
                    StaProtocol staProtocol2 = getClonedStation(devpThread, 1002);
                    StaProtocol staProtocol3 = getClonedStation(devpThread, 1003);
                    StaProtocol staProtocol4 = getClonedStation(devpThread, 1004);
                    StaProtocol staProtocol6 = getClonedStation(devpThread, 111);

                    boolean result = false;
                    switch (outSta.getStaNo()) {
                        case 105:
                            result = (staProtocol1 != null && staProtocol1.isLoading() && staProtocol.isLoading() && staProtocol.getStaNo() == 105);
                            break;
                        case 107:
                            result = (staProtocol2 != null && staProtocol2.isLoading());
                            break;
                        case 109:
                            result = (staProtocol3 != null && staProtocol3.isLoading());
                            break;
                        case 110:
                            result = ((staProtocol4 != null && staProtocol4.isLoading() && staProtocol.isLoading() && staProtocol.getStaNo() == 110) ||
                                    (staProtocol6 != null && staProtocol6.isLoading() && staProtocol.isLoading() && staProtocol.getStaNo() == 111));
                            break;
                        default:
                            break;
                    }

                    if (result) {
                        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();
                                staProtocol5.setWorkNo(workNo);
                                staProtocol5.setStaNo((short) 112);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol5));
                            }
                        } else {
                            if(staProtocol.isLoading() && (staProtocol.getStaNo() == 105 || staProtocol.getStaNo() == 110 ||  staProtocol.getStaNo() == 111)){
                                short workNo = staProtocol.getWorkNo();
                                staProtocol.setWorkNo(workNo);
                                staProtocol.setStaNo((short) 112);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("shiftTargetToCyclePoint error", e);
        }
    }

    /**
     * 获取站点并克隆
     */
    private StaProtocol getClonedStation(DevpThread devpThread, int staNo) {
        StaProtocol staProtocol = devpThread.getStation().get(staNo);
        return (staProtocol != null) ? staProtocol.clone() : null;
    }

    // 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.getStaNo() != 112 || staProtocol.getWorkNo() == 0 || !staProtocol.isLoading() || staProtocol.getWorkNo() > 9000 || staProtocol.getWorkNo() < 6000) {
                    continue;
                }
                // 查询任务信息
                TaskWrk taskWrk = taskWrkMapper.selectStaWorking(Integer.valueOf(staProtocol.getWorkNo()));
                if (taskWrk == null || taskWrk.getWrkNo() < 6001 || taskWrk.getWrkNo() > 9000) {
                    continue;
                }

                short workNo = staProtocol.getWorkNo();
                // 再写入目标站点
                staProtocol.setWorkNo(workNo);
                staProtocol.setStaNo(Short.valueOf(taskWrk.getTargetPoint()));
                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
                Thread.sleep(200);

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





    public synchronized void generateStoreWrkFile1() throws IOException, InterruptedException {
@@ -205,7 +320,7 @@
                                    staProtocol.setStaNo((short)107);
                                }else if (staProtocol.getWorkNo()>=9851&&staProtocol.getWorkNo()<=9875) {
                                    staProtocol.setStaNo((short)109);
                                }else{
                                }else if (staProtocol.getWorkNo()>=9876 && staProtocol.getWorkNo() <= 9900){
                                    staProtocol.setStaNo((short)110);
                                }
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
@@ -848,6 +963,12 @@
                        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                            break;
                        }
                        int storeCount = basDevpService.getStoreCount();
                        if(storeCount >= maxCount){
                            log.error("输送线暂存数达到上限{}",storeCount);
                            break;
                        }


                        // 已经存在吊车执行任务时，则过滤
                        if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {

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

@@ -1,30 +1,13 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.entity.StaDesc;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.zy.asrs.mapper.TaskWrkMapper;
import com.zy.asrs.entity.TaskWrk;
import com.zy.asrs.service.ApiLogService;
import com.zy.asrs.service.StaDescService;
import com.zy.asrs.service.TaskWrkService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.core.DevpThread;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.CrnTaskModeType;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.protocol.StaProtocol;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -32,8 +15,6 @@
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.HashMap;
import java.util.List;

@Slf4j
@@ -247,4 +228,14 @@
    public int saveToHistory(String taskNo) {
        return this.baseMapper.saveToHistory(taskNo);
    }

    @Override
    public int getStoreCount(Integer crnNo){
        return selectCount(new EntityWrapper<TaskWrk>().eq("crn_no", crnNo).in("wrk_sts",12,2));
    }

    @Override
    public TaskWrk selectStaWorking(Integer wrkNo){
        return this.baseMapper.selectStaWorking(wrkNo);
    }
}

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

@@ -5,9 +5,11 @@
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.WrkMastService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.List;


@Service("wrkMastService")
public class WrkMastServiceImpl extends ServiceImpl<WrkMastMapper, WrkMast> implements WrkMastService {
@@ -31,4 +33,9 @@
    public int getOutToStn182(Integer devpNo) {
        return selectCount(new EntityWrapper<WrkMast>().eq("sta_no", devpNo).in("wrk_sts",11,12));
    }

    @Override
    public int getStoreCount(Integer crnNo){
        return selectCount(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("wrk_sts",12,14,2));
    }
}

 src/main/java/com/zy/core/MainProcess.java

@@ -27,6 +27,9 @@
    // 频率
    private int i = 0;

    @Value("${wms.maxCirle}")
    private Integer maxCount;

    /**
     * =====>>  开始工作
     */
@@ -62,9 +65,14 @@
//                    mainService.outOfDevp();

                    // 其他  ===>> // 入出库模式切换函数
                    //环形循环函数
//                    mainService.shiftTargetToCyclePoint();
//                    mainService.shiftCyclePointToTarget();
                    i++;
                    if (i > 1) {
//                        mainService.ioConvert();
                    if (i > 2) {
                        //环形循环函数
                        mainService.shiftTargetToCyclePoint();
                        mainService.shiftCyclePointToTarget();
                        i = 0;
                    }


 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/model/protocol/Cycle.java

New file
@@ -0,0 +1,51 @@
package com.zy.core.model.protocol;

public class Cycle implements Cloneable {
    // 站点编号
    private Integer siteId;

    // 工作号
    private Short workNo = 0;

    // 目标站
    private Short staNo;

    public Cycle(Integer siteId, Short staNo) {
        this.siteId = siteId;
        this.staNo = staNo;
    }

    public Integer getSiteId() {
        return siteId;
    }

    public void setSiteId(Integer siteId) {
        this.siteId = siteId;
    }

    public Short getWorkNo() {
        return workNo;
    }

    public void setWorkNo(Short workNo) {
        this.workNo = workNo;
    }

    public Short getStaNo() {
        return staNo;
    }

    public void setStaNo(Short staNo) {
        this.staNo = staNo;
    }

    @Override
    public Cycle clone() {
        try {
            return (Cycle) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

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

@@ -392,33 +392,59 @@
//        array[9] = command.getSourceStaNo();
//        array[10] = command.getDestinationStaNo();
        array[9] = command.getCommand();

        OperateResult result18 = siemensNet.Write("DB100.18", (short)0);
        Thread.sleep(100L);
        OperateResult result = siemensNet.Write("DB100.0", array);

        int i=0;
//        if(result.IsSuccess){
//            log.info("堆垛机命令地址写入成功[id:{}]>>>>写入[{}]", slave.getId(),JSON.toJSON(command));
//        }else{
//            log.error("堆垛机命令地址写入失败！！！[id:{}]>>>>写入[{}]", slave.getId(),JSON.toJSON(command));
//        }
        do{
            //堆垛机任务写入后，回读一次，看是否成功
            Thread.sleep(300);
            OperateResultExOne<byte[]> resultRead = siemensNet.Read("DB101.0", (short) 56);
            if (result.IsSuccess) {
            Thread.sleep(100);
            OperateResultExOne<byte[]> resultRead = siemensNet.Read("DB100.0", (short) 20);
            if (resultRead.IsSuccess) {
                CrnCommand one=new CrnCommand();
                one.setTaskNo(siemensNet.getByteTransform().TransInt16(resultRead.Content, 2));
                if (!command.getTaskNo().equals(one.getTaskNo())
                one.setTaskMode(siemensNet.getByteTransform().TransInt16(resultRead.Content, 4));
                one.setSourcePosX(siemensNet.getByteTransform().TransInt16(resultRead.Content, 6));
                one.setSourcePosY(siemensNet.getByteTransform().TransInt16(resultRead.Content, 8));
                one.setSourcePosZ(siemensNet.getByteTransform().TransInt16(resultRead.Content, 10));
                one.setDestinationPosX(siemensNet.getByteTransform().TransInt16(resultRead.Content, 12));
                one.setDestinationPosY(siemensNet.getByteTransform().TransInt16(resultRead.Content, 14));
                one.setDestinationPosZ(siemensNet.getByteTransform().TransInt16(resultRead.Content, 16));
                if (!command.getTaskNo().equals(one.getTaskNo()) || !command.getTaskMode().equals(one.getTaskMode())
                        || !command.getSourcePosX().equals(one.getSourcePosX()) || !command.getSourcePosY().equals(one.getSourcePosY())
                        || !command.getSourcePosZ().equals(one.getSourcePosZ()) || !command.getDestinationPosX().equals(one.getDestinationPosX())
                        || !command.getDestinationPosY().equals(one.getDestinationPosY()) || !command.getDestinationPosZ().equals(one.getDestinationPosZ())
                ){
                    i++;
                    log.error("堆垛机命令地址写入后回读失败[id:{}]>>>>重写[{}] >>>>> 写入[{}],===>>回读[{}]", slave.getId(), i,JSON.toJSON(command),JSON.toJSON(one));
                    result = siemensNet.Write("DB100.0", array);
                }else{
                    i=5;
                    break;
                }
            }
        }while(i<5);

        if (command.getAckFinish() == 0) {
            short commandFinish = 1;
            Thread.sleep(100L);
            result = siemensNet.Write("DB100.18", commandFinish);
            int signFinish = 1;
            while (signFinish<5){
                OperateResultExOne<byte[]> result10018 = siemensNet.Read("DB100.18", (short) 2);
                short transInt16 = siemensNet.getByteTransform().TransInt16(result10018.Content, 0);
                if (transInt16 != commandFinish){
                    log.info("下发DB100.18  回读失败" + "commandFinish:"+commandFinish);
                    log.info("下发DB100.18  回读失败" + "array:"+ JSON.toJSONString(array));
                    result = siemensNet.Write("DB100.18", commandFinish);
                    signFinish++;
                }else {
                    log.info("下发DB100.18" + "commandFinish:"+commandFinish);
                    log.info("下发DB100.18" + "array:"+ JSON.toJSONString(array));
                    break;
                }
            }
        }

        try {
            // 日志记录

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

@@ -24,6 +24,7 @@
import com.zy.core.enums.SlaveType;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.Task;
import com.zy.core.model.protocol.Cycle;
import com.zy.core.model.protocol.StaProtocol;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
@@ -132,7 +133,7 @@
                        break;
                    // 写数据 ID+目标站
                    case 4:
                        writeAgvOk((StaProtocol)task.getData());
                        writeCycle((StaProtocol)task.getData());
                        read();
                        break;
                   /* case 3:
@@ -493,78 +494,185 @@

    }
    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;
        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){
            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);
            // **读取当前PLC状态，避免不必要的写入**
            OperateResultExOne<byte[]> readResult = siemensS7Net.Read(plcAddressWorkNo, (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)){
                        //任务命令写入成功
                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;
                }
            }

            // **清零并确认**
            if (!clearPLCData(plcAddressWorkNo, plcAddressStaNo, staProtocol.getSiteId())) {
                writeCount++;
                continue; // 重新尝试清零
            }

            // **写入新任务**
            if (writeTaskToPLC(plcAddressWorkNo, plcAddressStaNo, staProtocol)) {
                        writeFlag = true;
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                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);
                }
            } 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);
            }
            Thread.sleep(200);
        }

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

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

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

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

        if (index == -1) {
            log.error("站点编号 {} 不在已知列表中，无法写入任务！", staProtocol.getSiteId());
            return;
        }

        int writeCount = 0; // 任务下发尝试次数
        boolean writeFlag = false; // 任务下发成功标记
        String plcAddressWorkNo = "";
        String plcAddressStaNo = "" ;
        switch (staProtocol.getSiteId()){
            case 105:
                plcAddressWorkNo = "DB73." + 0;
                plcAddressStaNo = "DB73." + 4;
                break;
            case 106:
                plcAddressWorkNo = "DB73." + 6;
                plcAddressStaNo = "DB73." + (6 + 4);
                break;
            case 108:
                plcAddressWorkNo = "DB73." + 2 * 6;
                plcAddressStaNo = "DB73." + (2 * 6 + 4);
                break;
            case 110:
                plcAddressWorkNo = "DB73." + 3 * 6;
                plcAddressStaNo = "DB73." + (3 * 6 + 4);
                break;
            case 112:
                plcAddressWorkNo = "DB73." + 4 * 6;
                plcAddressStaNo = "DB73." + (4 * 6 + 4);
                break;
        }


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

        // **写入失败处理**
        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 writeResult2 = siemensS7Net.Write(plcAddressStaNo, staProtocol.getStaNo());

        OperateResult writeResult1 = siemensS7Net.Write(plcAddressWorkNo, staProtocol.getWorkNo().intValue());

        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 boolean writeTaskToPLC(String plcAddressWorkNo, String plcAddressStaNo, Cycle cycle) throws InterruptedException {
        OperateResult writeResult1 = siemensS7Net.Write(plcAddressWorkNo, cycle.getWorkNo().intValue());
        OperateResult writeResult2 = siemensS7Net.Write(plcAddressStaNo, cycle.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 == cycle.getWorkNo().intValue() && staNo == cycle.getStaNo();
            }
        }
        return false;
    }

    /**
     * 处理写入失败的情况
     */
    private void handleWriteFailure(StaProtocol staProtocol, boolean writeFlag) {
        if(!writeFlag){
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                staProtocol.setPakMk(true);
            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(staProtocol)));
            log.error("写入输送线命令尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));

//            //重新添加数据到任务队列
//            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
//            read();//读取1次设备状态
            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));

//            Integer siteId = staProtocol.getSiteId();
//            staProtocol = station.get(siteId);
//            if ((siteId == 101 || siteId == 201)&&(staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0)) {
//                staProtocol.setPakMk(true);
//            }
            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:
@@ -44,6 +44,9 @@
  publicKeysStorePath: publicCerts.keystore

wms:
  #输送线暂存数
  count: 8
  maxCirle: 3
  # 是否开启上报
  start: true
  # WMS系统ip

 src/main/resources/mapper/TaskWrkMapper.xml

@@ -134,4 +134,10 @@
        order by io_pri desc,create_time,wrk_no ASC
    </select>

    <select id="selectStaWorking" resultMap="BaseResultMap">
        select top 1 * from dbo.wcs_task_wrk_log
        where wrk_no = #{workNo}
        order by create_time DESC
    </select>

</mapper>