#空托盘程序

Junjie

2025-07-22 cbeff29a3261cb13ed3c5aada8bbd9cc4c1fee72

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

@@ -6,6 +6,7 @@
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.BasCrnErrorMapper;
@@ -13,7 +14,7 @@
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.constant.RedisConstantType;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
@@ -22,6 +23,7 @@
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.News;
import com.zy.common.utils.RedisUtil;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.cache.MessageQueue;
@@ -39,6 +41,8 @@
import com.zy.core.thread.LedThread;
import com.zy.core.thread.RgvThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -91,6 +95,10 @@
    private WrkMastService wrkMastService;
    @Autowired
    private WrkMastLogService wrkMastLogService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private RedisUtil redisUtil;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -225,9 +233,14 @@
                            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                                    .eq("loc_no", dto.getLocNo()));

                            short staNo = dto.getStaNo().shortValue();
                            if (inSta.getStaNo() == 1002) {
                                staNo = 2002;
                            }

                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            staProtocol.setStaNo(staNo);
                            staProtocol.setPalletSize(locMast.getLocType2());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -450,6 +463,7 @@
                        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
                        wrkMast.setSourceLocNo(""); // 源库位清空
                        wrkMast.setModiTime(now);
                        wrkMast.setUpdMk("");//允许再次移库
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            throw new CoolException("更新工作档数据状态失败");
                        }
@@ -627,59 +641,147 @@
    }

    /**
     * 回原点，堆垛机没有执行中任务，设备存在入库任务时叫回原点
     * 堆垛机无任务两分钟，回入库口待机
     */
    public synchronized void crnRebackHp(CrnProtocol crnProtocol, CrnThread crnThread) {
//        for (CrnSlave crn : slaveProperties.getCrn()) {
//            // 获取堆垛机信息
//            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
//            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
//            if (crnProtocol == null) {
//                continue;
//            }
//            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
//            if (basCrnp == null) {
//                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
//                continue;
//            }
        if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
            if (crnProtocol.getBay() == 1 && crnProtocol.getLevel() == 1) {
                return;
    public synchronized void crnMove() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            if (crn.getId() == 1) {
                continue;
            }

            // 已经存在吊车执行任务时，则过滤3,12
            if (wrkMastMapper.selectWorking(crnProtocol.getCrnNo()) != null) {
                return;
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) {
                continue;
            }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

            //堆垛机有执行中任务，过滤3,4,11,12
            if (wrkMastMapper.selectCrnWorking(crnProtocol.getCrnNo()) != null) {
                return;
            }
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                if (crnProtocol.getBay() == 1 && crnProtocol.getLevel() == 1) {
                    continue;
                }

            //输送线没有入库任务，过滤2
            if (wrkMastMapper.selectDevWorking(crnProtocol.getCrnNo()) == null) {
                return;
                if (System.currentTimeMillis() - crnProtocol.getLastCommandTime() < 1000 * 60 * 2) {
                    continue;
                }

                Object object = redisUtil.get(RedisConstantType.CRN_MOVE_LOCK);
                if (object != null) {
                    continue;
                }

                List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                        .eq("crn_no", crn.getId())
                        .notIn("wrk_sts", 5, 14, 15)
                );
                if (!wrkMasts.isEmpty()) {
                    continue;
                }

                CrnSlave.CrnStn crnStn = crn.getCrnInStn().get(0);

                News.info("堆垛机无任务自动回入库口待机==>>" + crnProtocol.getCrnNo() + "号堆垛机");
                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo((short) 9999); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.CRN_MOVE); // 任务模式:  堆垛机移动
                crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                crnCommand.setSourcePosY((short) 1);     // 源库位列
                crnCommand.setSourcePosZ((short) 1);     // 源库位层
                crnCommand.setDestinationPosX((short) 0);     // 目标库位排
                crnCommand.setDestinationPosY((short) 0);     // 目标库位列
                crnCommand.setDestinationPosZ((short) 0);     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) {
                    News.error("堆垛机移动命令下发失败，堆垛机号={}，任务数据={}", crnProtocol.getCrnNo(), JSON.toJSON(crnCommand));
                }
                crnThread.setBackHpFlag(true);
                redisUtil.set(RedisConstantType.CRN_MOVE_LOCK + crn.getId(), "lock", 60);
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            News.info("堆垛机召回原点==>>" + crnProtocol.getCrnNo() + "号堆垛机有入库任务,召回原点");
            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
            crnCommand.setTaskNo((short) 9999); // 工作号
            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
            crnCommand.setTaskMode(CrnTaskModeType.GO_ORIGIN); // 任务模式:  回原点
            crnCommand.setSourcePosX((short) 0);     // 源库位排
            crnCommand.setSourcePosY((short) 0);     // 源库位列
            crnCommand.setSourcePosZ((short) 0);     // 源库位层
            crnCommand.setDestinationPosX((short) 0);     // 目标库位排
            crnCommand.setDestinationPosY((short) 0);     // 目标库位列
            crnCommand.setDestinationPosZ((short) 0);     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) {
                News.error("堆垛机回原点命令下发失败，堆垛机号={}，任务数据={}", crnProtocol.getCrnNo(), JSON.toJSON(crnCommand));
            }
            crnThread.setBackHpFlag(true);
        }
//        }
    }

    /**
     * 堆垛机有入库任务时，回入库口待机
     */
    public synchronized void crnMoveByInTask() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            if (crn.getId() == 1) {
                continue;
            }

            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) {
                continue;
            }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                if (crnProtocol.getBay() == 1 && crnProtocol.getLevel() == 1) {
                    continue;
                }

                if (System.currentTimeMillis() - crnProtocol.getLastCommandTime() < 1000 * 60) {
                    continue;
                }

                Object object = redisUtil.get(RedisConstantType.CRN_MOVE_LOCK);
                if (object != null) {
                    continue;
                }

                List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                        .eq("crn_no", crn.getId())
                        .eq("wrk_sts", 2)
                );
                if (wrkMasts.isEmpty()) {
                    continue;
                }

                CrnSlave.CrnStn crnStn = crn.getCrnInStn().get(0);

                News.info("堆垛机有入库任务时，回入库口待机==>>" + crnProtocol.getCrnNo() + "号堆垛机");
                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo((short) 9999); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.CRN_MOVE); // 任务模式:  堆垛机移动
                crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                crnCommand.setSourcePosY((short) 1);     // 源库位列
                crnCommand.setSourcePosZ((short) 1);     // 源库位层
                crnCommand.setDestinationPosX((short) 0);     // 目标库位排
                crnCommand.setDestinationPosY((short) 0);     // 目标库位列
                crnCommand.setDestinationPosZ((short) 0);     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) {
                    News.error("堆垛机移动命令下发失败，堆垛机号={}，任务数据={}", crnProtocol.getCrnNo(), JSON.toJSON(crnCommand));
                }
                crnThread.setBackHpFlag(true);
                redisUtil.set(RedisConstantType.CRN_MOVE_LOCK + crn.getId(), "lock", 60);
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
@@ -762,21 +864,27 @@
                LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                    News.warnNoLog(""+mark+" - 1"+" - 9"+" - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位状态={}",shallowLoc.getLocSts());
                    News.warn(""+mark+" - 1"+" - 9"+" - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位={},库位状态={}",shallowLoc.getLocNo(),shallowLoc.getLocSts());
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                    if (null == waitWrkMast) {
                        News.error(""+mark+" - 1"+" - 10"+" - {}库位异常，未检索到相应工作档！", shallowLocNo);
                    } else {
                        waitWrkMast.setIoPri(15D);
                        waitWrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                            News.error(""+mark+" - 1"+" - 11"+" - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                        if (waitWrkMast.getWrkSts() != 14 && waitWrkMast.getIoType() > 100) {
                            waitWrkMast.setIoPri(15D);
                            waitWrkMast.setModiTime(new Date());
                            if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                News.error(""+mark+" - 1"+" - 11"+" - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                            }
                            continue;
                        }
                        continue;

                        if(waitWrkMast.getWrkSts() < 5 && waitWrkMast.getIoType() < 100) {
                            continue;//有任务禁止搬运，有可能浅库位状态还未变更完成
                        }
                    }

                } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                    News.warnNoLog(""+mark+" - 1"+" - 12"+" - // F、D  库位状态={}",shallowLoc.getLocSts());
                    News.warn(""+mark+" - 1"+" - 12"+" - // F、D  库位={},库位状态={}",shallowLoc.getLocNo(),shallowLoc.getLocSts());
                    // 此标记避免多次执行移库任务
                    if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())) {
                        if (moveLocForDeepLoc(slave, shallowLoc,mark)){
@@ -794,7 +902,7 @@
                    }
                    continue;
                } else if (shallowLoc.getLocSts().equals("Q")) {
                    News.warnNoLog(""+mark+" - 1"+" - 13"+" - // Q  库位状态={}",shallowLoc.getLocSts());
                    News.warn(""+mark+" - 1"+" - 13"+" - // Q  库位={},库位状态={}",shallowLoc.getLocNo(),shallowLoc.getLocSts());
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                    if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                        News.infoNoLog(""+mark+" - 1"+" - 14"+" - // F、D  工作状态(判断条件为==4)={}",waitWrkMast.getWrkSts());
@@ -802,7 +910,7 @@
                    }
                }
            }
            News.warnNoLog(""+mark+" - 1"+" - 15"+" - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}",wrkMast.getWrkNo().shortValue()
            News.info(""+mark+" - 1"+" - 15"+" - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}",wrkMast.getWrkNo().shortValue()
                    ,crnStn.getRow().shortValue(),crnStn.getBay().shortValue(),crnStn.getLev().shortValue()
                    ,locMast.getRow1().shortValue(),locMast.getBay1().shortValue(),locMast.getLev1().shortValue());

@@ -853,6 +961,20 @@
     */
    public synchronized void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol,Integer mark) {
        News.warnNoLog(""+mark+" - 2"+" - 0"+" - 堆垛机入出库作业下发：执行出库");

        int devpTaskStackOver = 20;
        Config config = configService.selectOne(new EntityWrapper<Config>()
                .eq("code", "devpTaskStackOver"));
        if(config != null) {
            devpTaskStackOver = Integer.parseInt(config.getValue());
        }

        Integer devpWorkingCount = commonService.queryDevpWorkingCount();
        if (devpWorkingCount > devpTaskStackOver) {
            News.warn("" + mark + " - 2" + " - 0" + " - 输送线任务过载，当前输送线承载数量:{}", devpWorkingCount);
            return;
        }

        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
//            WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
@@ -911,7 +1033,23 @@
                }
                // 判断堆垛机出库站状态
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                        && staProtocol.getWorkNo() == 0) {

                    //根据参数判断是否校验可出信号
                    String crnOutVerifyOut = "Y";
                    Config crnOutVerifyOutEnableConfig = configService.selectOne(new EntityWrapper<Config>()
                            .eq("code", "crnOutVerifyOutEnable"));
                    if(crnOutVerifyOutEnableConfig != null) {
                        crnOutVerifyOut = crnOutVerifyOutEnableConfig.getValue();
                    }

                    if (crnOutVerifyOut.equals("Y")) {
                        if (!staProtocol.isOutEnable()) {
                            continue;
                        }
                    }


                    // 命令下发区 --------------------------------------------------------------------------

                    // 堆垛机控制过滤
@@ -922,7 +1060,7 @@

                    if (crnProtocol.getCrnNo() == 1) {
                        //判断堆垛机和当前任务是否处于一个巷道
                        if (Utils.getLaneByLocNo(wrkMast.getLocNo()) != crnProtocol.getCrnLane()) {
                        if (Utils.getLaneByLocNo(wrkMast.getSourceLocNo()) != crnProtocol.getCrnLane()) {
                            //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
                            List<WrkMast> currentWrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), false);
                            if (!currentWrkMasts.isEmpty()) {
@@ -938,7 +1076,7 @@
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            News.warnNoLog(""+mark+" - 2"+" - 7"+" - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位状态={}",shallowLoc.getLocSts());
                            News.warnNoLog(""+mark+" - 2"+" - 7"+" - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位={},库位状态={}",shallowLoc.getLocNo(),shallowLoc.getLocSts());
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null == waitWrkMast) {
                                News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
@@ -955,7 +1093,7 @@
                                }
                            }
                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            News.warnNoLog(""+mark+" - 2"+" - 9"+" - // F、D  库位状态={}",shallowLoc.getLocSts());
                            News.warnNoLog(""+mark+" - 2"+" - 9"+" - // F、D  库位={},库位状态={}",shallowLoc.getLocNo(),shallowLoc.getLocSts());
//                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            //2022-08-16 modify,不根据updmk标记移库任务(容易被取消导致堵塞)，查询工作档是否存在任务
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
@@ -976,7 +1114,7 @@
                            News.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo);
                            continue;
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                            News.warnNoLog(""+mark+" - 2"+" - 10"+" - // Q、S  库位状态={}",shallowLoc.getLocSts());
                            News.warnNoLog(""+mark+" - 2"+" - 10"+" - // Q、S  库位={},库位状态={}",shallowLoc.getLocNo(),shallowLoc.getLocSts());
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                            if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                                News.infoNoLog(""+mark+" - 2"+" - 11"+" - // F、D  工作状态(判断条件为==4)={}",waitWrkMast.getWrkSts());
@@ -1497,13 +1635,43 @@
                    continue;
                }

                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, emptyInSta.getBarcode());
                if (barcodeThread == null) {
                    continue;
                }

                // 站点条件判断
                if (staProtocol.isAutoing()
                        && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk()
                        && (staProtocol.getWorkNo() > 9990 && staProtocol.getWorkNo() <= 9999)
                        && staProtocol.isPakMk()) {
                        && staProtocol.isPakMk()
                        && staProtocol.getEmptyInType() == 1
                ) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行：空栈板初始化入库,叉车入库站放货");

                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            News.info(""+mark+" - 2"+" - 扫码失败1 ===>> {}号条码扫描器检测条码信息：{},站点:{}", emptyInSta.getBarcode(), barcode, emptyInSta.getStaNo());
                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = "扫码失败，请重试";
                                MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
                            }
                            continue;
                        }
                    } else {
                        News.info(""+mark+" - 3"+" - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", emptyInSta.getBarcode(), barcode, emptyInSta.getStaNo());
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
                        }
                        continue;
                    }

                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
@@ -1512,6 +1680,7 @@
                        param.setIoType(10);
                        param.setSourceStaNo(emptyInSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        param.setBarcode(barcode);
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
@@ -1531,31 +1700,7 @@
                                News.errorNoLog(""+mark+" - 1"+" - 更新plc站点信息失败");
                                throw new CoolException("更新plc站点信息失败");
                            }

                            if (ledThread != null) {
                                // 命令集合
                                List<LedCommand> commands = new ArrayList<>();
                                // 组装命令
                                LedCommand ledCommand = new LedCommand();
                                ledCommand.setWorkNo(dto.getWorkNo());
                                ledCommand.setIoType(1);
                                ledCommand.setTitle("全板入库");
                                ledCommand.setLocNo(dto.getLocNo());
                                ledCommand.setStaNo(dto.getStaNo());
                                commands.add(ledCommand);
                                MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(3, commands));
//                                ledThread.errorReset();
                            }
                        } else {
                            staProtocol.setWorkNo((short)9992);
                            staProtocol.setStaNo(emptyInSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.errorNoLog(""+mark+" - 2"+" - 更新plc站点信息失败");
                                throw new CoolException("更新plc站点信息失败");
                            }

                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
                                if (!Cools.isEmpty(errorMsg)) {
@@ -1566,9 +1711,115 @@
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
                } else {
                    News.errorNoLog(""+mark+" - 4"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isAutoing()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk());
                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 空栈板初始化入库,叉车入库站放货执行完成");
    }

    /**
     * 空托盘入库-产线
     */
    public synchronized void storeEmptyPltLine(Integer mark) {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历空板入库口
            for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
                // 获取空板入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(emptyInSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                LedThread ledThread = null;
                if (!Cools.isEmpty(emptyInSta.getLed()))  {
                    ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());
                }

                if (!staProtocol.isLoading()){
                    continue;
                }

                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, emptyInSta.getBarcode());
                if (barcodeThread == null) {
                    continue;
                }

                // 站点条件判断
                if (staProtocol.isAutoing()
                        && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk()
                        && (staProtocol.getWorkNo() > 9990 && staProtocol.getWorkNo() <= 9999)
                        && staProtocol.isPakMk()
                        && staProtocol.getEmptyInType() == 2
                ) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行：空栈板初始化入库,叉车入库站放货");

                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            News.info(""+mark+" - 2"+" - 扫码失败1 ===>> {}号条码扫描器检测条码信息：{},站点:{}", emptyInSta.getBarcode(), barcode, emptyInSta.getStaNo());
                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = "扫码失败，请重试";
                                MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
                            }
                            continue;
                        }
                    } else {
                        News.info(""+mark+" - 3"+" - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", emptyInSta.getBarcode(), barcode, emptyInSta.getStaNo());
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
                        }
                        continue;
                    }

                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                            .eq("barcode", barcode)
                    );
                    if(wrkMast != null) {
                        continue;
                    }

                    int workNo = commonService.getWorkNo(3);
                    // 生成工作档
                    WrkMast wrkMast1 = new WrkMast();
                    wrkMast1.setWrkNo(workNo);
                    wrkMast1.setIoTime(new Date());
                    wrkMast1.setWrkSts(2L); // 工作状态：设备上走
                    wrkMast1.setIoType(3); // 入出库状态：3.站到站
                    wrkMast1.setIoPri(13D); // 优先级
                    wrkMast1.setSourceStaNo(emptyInSta.getStaNo());
                    wrkMast1.setStaNo(1007);
                    wrkMast1.setBarcode(barcode);
                    // 操作人员数据
                    wrkMast1.setAppeTime(new Date());
                    wrkMast1.setModiTime(new Date());
                    boolean res = wrkMastService.insert(wrkMast1);
                    if (!res) {
                        throw new CoolException("保存工作档失败");
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo((short) workNo);
                    staProtocol.setStaNo((short) 2003);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        News.errorNoLog(""+mark+" - 1"+" - 更新plc站点信息失败");
                        throw new CoolException("更新plc站点信息失败");
                    }
                } else {
                    News.errorNoLog(""+mark+" - 4"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isAutoing()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
@@ -1823,10 +2074,11 @@
            List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
            for (LocDetl locDetl : locDetls) {
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(locDetl);
                wrkDetl.setWrkNo(workNo);
                wrkDetl.setIoTime(now);
                wrkDetl.setAnfme(locDetl.getAnfme());
                VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
//                VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
                wrkDetl.setAppeTime(now);
                wrkDetl.setModiTime(now);
                if (!wrkDetlService.insert(wrkDetl)) {
@@ -1947,10 +2199,11 @@

                        for (LocDetl locDetl : locDetls) {
                            WrkDetl wrkDetl = new WrkDetl();
                            wrkDetl.sync(locDetl);
                            wrkDetl.setWrkNo(workNo);
                            wrkDetl.setIoTime(new Date());
                            wrkDetl.setAnfme(locDetl.getAnfme());
                            VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
//                            VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
                            wrkDetl.setAppeTime(new Date());
                            wrkDetl.setModiTime(new Date());
                            if (!wrkDetlService.insert(wrkDetl)) {
@@ -2161,16 +2414,19 @@

    // RGV  ===>> 执行对RGV操作
    public synchronized void rgvExecute(Integer mark) {
        ArrayList<Integer> list = new ArrayList<Integer>(){{add(1090);add(1091);}};
        ArrayList<Integer> list = new ArrayList<Integer>(){{add(2003);add(2002);}};
        for (Integer staNo : list) {
            Integer devpId = null;
            Integer rgvStaNoDevpId = null;
            Integer rgvStaNo = null;
            if (staNo == 1090) {
            if (staNo == 2003) {
                devpId = 1;
                rgvStaNo = 1091;
                rgvStaNo = 2002;
                rgvStaNoDevpId = 2;
            }else {
                devpId = 2;
                rgvStaNo = 1090;
                rgvStaNo = 2003;
                rgvStaNoDevpId = 1;
            }

            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devpId);
@@ -2191,7 +2447,49 @@
            ) {
                WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                        .eq("wrk_no", staProtocol.getWorkNo()));

                if (wrkMast == null) {
                    continue;
                }

                if (wrkMast.getWrkSts() == 201) {
                    continue;
                }

                SiemensDevpThread devpThread2 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, rgvStaNoDevpId);
                if (devpThread2 == null) {
                    continue;
                }
                StaProtocol staProtocolRgvStaNo = devpThread2.getStation().get(rgvStaNo);
                if (staProtocolRgvStaNo == null) {
                    continue;
                }

                if (!staProtocolRgvStaNo.isAutoing()) {
                    continue;
                }

                if (staProtocolRgvStaNo.isLoading()) {
                    continue;
                }

                // 获取RGV信息
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, 1);
                if (rgvThread == null) {
                    continue;
                }

                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }

                if (rgvProtocol.statusType1 != RgvStatusType.IDLE && rgvProtocol.getTaskNo1() != 0) {
                    continue;
                }

                Object object = redisUtil.get(RedisConstantType.RGV_MOVE_LOCK + wrkMast.getWrkNo());
                if (object != null) {
                    continue;
                }

@@ -2212,6 +2510,7 @@
                wrkMast.setWrkSts(201L);//201.RGV搬运中
                wrkMast.setModiTime(new Date());
                wrkMastService.updateById(wrkMast);
                redisUtil.set(RedisConstantType.RGV_MOVE_LOCK + wrkMast.getWrkNo(), "lock", 60 * 60);
            }
        }
    }
@@ -2231,7 +2530,7 @@
            }

            //  状态：等待确认 并且  任务完成位 = 1
            if (rgvProtocol.statusType == RgvStatusType.WAITING && rgvProtocol.getTaskNo1() != 0) {
            if (rgvProtocol.statusType1 == RgvStatusType.WAITING && rgvProtocol.getTaskNo1() != 0) {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行对RGV工作档的完成操作");
                // 获取入库待确认工作档
                WrkMast wrkMast = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
@@ -2240,25 +2539,30 @@
                    continue;
                }

                if (Cools.isEmpty(wrkMast.getMemo())) {
                    News.error(""+mark+" - 1"+" - RGV处于等待确认且任务完成状态，但工作档数据异常。RGV号={}，工作号={}", rgvSlave.getId(), rgvProtocol.getTaskNo1());
                if (wrkMast.getWrkSts() != 201) {
                    continue;
                }

                if (wrkMast.getIoType() == 3) {
                    //站到站走另外一个方法
                    continue;
                }

                Integer devpId = null;
                Integer devpStaNo = null;
                String locNo = null;
                Long updateWrkSts = null;
                if (wrkMast.getIoType() < 100) {
                    //入库
                    wrkMast.setWrkSts(2L);
                    updateWrkSts = 2L;
                    devpId = 1;
                    devpStaNo = 1090;
                    devpStaNo = 2003;
                    locNo = wrkMast.getLocNo();
                }else {
                    //出库
                    wrkMast.setWrkSts(15L);
                    updateWrkSts = 15L;
                    devpId = 2;
                    devpStaNo = 1091;
                    devpStaNo = 2002;
                    locNo = wrkMast.getSourceLocNo();
                }

@@ -2285,10 +2589,88 @@
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败");
                    }
                    wrkMastMapper.updateWrkSts(updateWrkSts, wrkMast.getWrkNo());
                    rgvThread.setResetFlag1(true);
                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 对工作档的完成操作执行完成");
    }

                    Date now = new Date();
                    wrkMast.setModiTime(now);
                    wrkMastMapper.updateById(wrkMast);
    // RGV  ===>> 执行对RGV工作档的完成操作 站到站
    public synchronized void rgvFinished2(Integer mark) {
        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
            // 获取RGV信息
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            if (rgvThread == null) {
                continue;
            }

            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                continue;
            }

            //  状态：等待确认 并且  任务完成位 = 1
            if (rgvProtocol.statusType1 == RgvStatusType.WAITING && rgvProtocol.getTaskNo1() != 0) {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行对RGV工作档的完成操作");
                // 获取入库待确认工作档
                WrkMast wrkMast = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
                if (wrkMast == null) {
                    News.error(""+mark+" - 1"+" - RGV处于等待确认且任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgvSlave.getId(), rgvProtocol.getTaskNo1());
                    continue;
                }

                if (wrkMast.getWrkSts() != 201) {
                    continue;
                }

                if (wrkMast.getIoType() != 3) {
                    //不是站到站
                    continue;
                }

                Integer devpId = 2;
                Integer devpStaNo = 2002;

                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devpId);
                StaProtocol staProtocol = devpThread.getStation().get(devpStaNo);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.getWorkNo() == 0
                ) {

                    short locType2 = 1;
                    String barcode = wrkMast.getBarcode();
                    if (barcode.startsWith("11")) {
                        locType2 = 1;
                    } else if (barcode.startsWith("13")) {
                        locType2 = 2;
                    } else if (barcode.startsWith("16")) {
                        locType2 = 3;
                    } else {
                        continue;
                    }

                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    staProtocol.setPalletSize(locType2);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpId, new Task(2, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败");
                    }
                    rgvThread.setResetFlag1(true);

                    wrkMastService.delete(new EntityWrapper<WrkMast>()
                            .eq("wrk_no", wrkMast.getWrkNo()));
                }
            }
        }