#限制线体上托盘数量

lty

6 天以前 0b6c8b7687ff593d254cfcacacf72a75bfdf11ca

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

@@ -3,7 +3,6 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.exception.CoolException;
@@ -13,6 +12,7 @@
import com.zy.asrs.utils.RouteUtils;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.constant.GhjtApiConstant;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
@@ -21,7 +21,6 @@
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.RedisUtil;
import com.zy.common.utils.RgvUtils;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.cache.MessageQueue;
@@ -39,6 +38,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.mapper.ConfigMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -46,6 +47,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@@ -101,6 +103,9 @@
    private BasRgvMapMapper basRgvMapMapper;
    @Autowired
    private RgvOneSignMapper rgvOneSignMapper;

    @Resource
    private ConfigMapper configMapper;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -881,6 +886,48 @@
            }
        }
    }
    /**
     * 堆垛机站出库到出库站
     */
    public synchronized void crnStnToOutStn1() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                // 查询工作档
                WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(crnStn.getStaNo());
                if (wrkMast == null) {
                    continue;
                }
                // 判断工作档条件
                if ((wrkMast.getIoType() < 100 && wrkMast.getIoType() != 12) || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                    continue;
                }
                // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                    // 移动中
                    continue;
                }
                //  判断堆垛机状态等待确认
                if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
                        && crnProtocol.statusType == CrnStatusType.WAITING
                        && crnProtocol.forkPosType == CrnForkPosType.HOME) {

                    // 命令下发区 --------------------------------------------------------------------------
                    // 更新工作档状态为14
                    wrkMast.setWrkSts(13L);
                    wrkMast.setCrnEndTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) != 0) {
                        // 复位堆垛机
                        crnThread.setResetFlag(true);
                    } else {
                        log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                    }
                }
            }
        }
    }

    /**
     * 堆垛机站出库到出库站
@@ -1275,28 +1322,28 @@
                continue;
            }

            boolean flag = false;
            boolean flag = true;
            // 获取堆垛机入库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
            if (staProtocol == null) {
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                flag = true;
            }
            if (!flag) {
                continue;
            }
//            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
//            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
//            if (staProtocol == null) {
//                continue;
//            } else {
//                staProtocol = staProtocol.clone();
//            }
//            // 查询站点详细信息
//            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
//            if (staDetl == null) {
//                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
//                continue;
//            }
//            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
//                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
//                flag = true;
//            }
//            if (!flag) {
//                continue;
//            }

            // 获取库位信息
            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
@@ -1357,18 +1404,19 @@
                }
            }

            // 命令下发区 --------------------------------------------------------------------------
            // 入库命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
            //crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
            //crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
            //crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
            crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 目标库位排
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            crnCommand.setSourceStaNo(crnStn.getPlatNo().shortValue());     // 源库位排
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
@@ -1529,7 +1577,17 @@
     */
    public synchronized void locToCrnStn1(CrnSlave slave, CrnProtocol crnProtocol) {
        List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep12(slave.getId());
        Integer count = wrkMastMapper.countPakOut();

        for (WrkMast wrkMast : wrkMasts) {
            if(count > 30){ //设备上走托盘不超过30个
                continue;
            }
            // 判断堆垛机站点是否可用
            if (!crnEnabled(wrkMast)){
                continue;
            }

            if (wrkMast == null) {
                continue;
            }
@@ -1545,17 +1603,12 @@
                continue;
            }

            log.info("{}号堆垛机选定的出库口是{}",crnProtocol.getCrnNo(),crnStn.getPlatNo());

            // 工作档状态判断
            if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null) {
            if ((wrkMast.getIoType() < 100 && wrkMast.getIoType()!=12) || wrkMast.getSourceStaNo() == null) {
                log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                continue;
            }
            //退库模式跳过118、119出库任务
            if (wrkMast.getStaNo()==118 || wrkMast.getStaNo()==119){
                RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign();
                if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()==1){
                    continue;
                }
            }
            // 获取源库位信息
            LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
@@ -1564,20 +1617,20 @@
                continue;
            }
            // 获取堆垛机出库站信息
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
            if (staProtocol == null) {
                break;
//                    continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            //SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            //StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
//            if (staProtocol == null) {
//                break;
////                    continue;
//            } else {
//                staProtocol = staProtocol.clone();
//            }

//            // 入出库模式判断
//            if (devpThread.ioMode != IoModeType.PAKOUT_MODE) { continue; }
            if (wrkMast.getStaNo() == 204 && devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) {
                continue;
            }
//            if (wrkMast.getStaNo() == 204 && devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) {
//                continue;
//            }

            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
@@ -1587,8 +1640,9 @@
//                    continue;
            }
            // 判断堆垛机出库站状态
            if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                    && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
            //if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
            //        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
            if (staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")) {
                // 命令下发区 --------------------------------------------------------------------------

                // 堆垛机控制过滤
@@ -1632,7 +1686,7 @@
                            moveLocForDeepLoc(slave, shallowLoc);
                        }
                        log.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo);
                        continue;
                        break;
                    } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                        WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                        if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
@@ -1647,7 +1701,7 @@
//                        return;
                }

                // 1.堆垛机开始移动
                // 1.堆垛机开始移动   出库命令
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
@@ -1656,9 +1710,10 @@
                crnCommand.setSourcePosX(sourceSta.getRow1().shortValue());     // 源库位排
                crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
                crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue());     // 源库位层
                crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
//                crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
//                crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
//                crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                crnCommand.setDestinationStaNo(crnStn.getPlatNo().shortValue());
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
@@ -1675,6 +1730,69 @@
            }
        }

    }

    /**
     * 确认出库码头是否可用
     * @param wrkMast 工作档
     * @return 是否可用
     */
    private boolean crnEnabled(WrkMast wrkMast) {

        // 获取请求头
        Map<String,Object> headers = new HashMap<>();
        headers.put("digi-type","sync ");
        headers.put("digi-protocol","raw");
        headers.put("digi-datakey"," XCommon.ImportData");

        // 构造请求体
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("staNo", wrkMast.getSourceStaNo());
        jsonObject.put("workNo", wrkMast.getWrkNo());
        String body = jsonObject.toJSONString();

        boolean success;
        String response;
        try {
            response = new HttpHandler.Builder()
                    .setUri(GhjtApiConstant.GWCS_IP_PORT)
                    .setPath(GhjtApiConstant.GWCS_CKMT_URL)
                    .setHeaders(headers)
                    .setJson(body)
                    .build()
                    .doPost();
            if (!Cools.isEmpty(response)) {
                JSONObject jsonObject1 = JSONObject.parseObject(response);
                if ((Integer) jsonObject1.get("code") == 200 && (Integer) jsonObject1.get("data") == 1){
                    success = true;
                }else {
                    success = false;
                }
            } else {
                log.error("确认出库码头是否可用失败！！！url：{}；request：{}；response：{}", GhjtApiConstant.GWCS_IP_PORT + GhjtApiConstant.GWCS_CKMT_URL, body, response);
                throw new CoolException("确认出库码头是否可用失败");
            }
        } catch (Exception e) {
            success = false;
            log.error("确认出库码头是否可用异常，工作号：{}，{}", wrkMast.getWrkNo(),e.getMessage());
        } finally {

//            try {
//                // 保存接口日志
//                apiLogService.save(
//                        "从出库码头到出库口",
//                        MesConstant.URL + MesConstant.PAKIN_URL,
//                        null,
//                        "127.0.0.1",
//                        jsonObject.toJSONString(),
//                        response,
//                        success
//                );
//            } catch (Exception e) {
//                log.error("接口日志保存异常", e);
//            }
        }
        return success;
    }

    /**
@@ -1854,6 +1972,49 @@
        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
            return;
        }
        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
        if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
            String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
            LocMast shallowLoc = locMastService.selectById(shallowLocNo);
            // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
            if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                if (null == waitWrkMast) {
                    log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                } else {
                    if (waitWrkMast.getWrkSts() == 11) {
                        waitWrkMast.setIoPri(15D);
                        waitWrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                            log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                        }
                       return;
                    } else {

                    }
                }
            } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
//                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                //2022-08-16 modify,不根据updmk标记移库任务(容易被取消导致堵塞)，查询工作档是否存在任务
                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                // 此标记避免多次执行移库任务
//                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
//                                || Cools.isEmpty(waitWrkMast)) {
                if (Cools.isEmpty(waitWrkMast)) {
                    wrkMast.setUpdMk("Y");
                    wrkMastMapper.updateById(wrkMast);
                    // 生成工作档,将浅库位移转到新的库位中
                    moveLocForDeepLoc(slave, shallowLoc);
                }
                log.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo);
                return;
            } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                    return;
                }
            }
        }

        // 已经存在吊车执行任务时，则过滤
        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
@@ -1913,6 +2074,9 @@
                    // 入库 + 库位转移  ==> 4.入库完成
                    if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) {
                        wrkMast.setWrkSts(4L);
                        if (wrkMast.getIoType() == 3) {
                            wrkMast.setWrkSts(13L);
                        }
                    } else {
                        continue;
                    }
@@ -2604,9 +2768,18 @@
        try {
            List<Integer> rows = locMastService.queryDistinctRow(crn.getId());
            LocMast loc = null;

            // 获取备货区配置
            Config config = configMapper.selectConfigByCode("auto_stock_up");
            if (config == null) {
                return;
            }
            // 备货取是前几列
            int bay1 = Integer.parseInt(config.getValue());

            for (Integer row : rows) {
                if (Utils.isDeepLoc(slaveProperties, row)) {
                    loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1());
                    loc = locMastService.queryFreeLocMastNotBay(row, shallowLoc.getLocType1(),bay1);

                    if (loc != null) {
                        if (Utils.isDeepLoc(slaveProperties, loc.getLocNo())) {
@@ -2625,7 +2798,7 @@
            if (null == loc) {
                for (Integer row : rows) {
                    if (Utils.isShallowLoc(slaveProperties, row)) {
                        loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1());
                        loc = locMastService.queryFreeLocMastNotBay(row, shallowLoc.getLocType1(),bay1);

                        if (null != loc) {//对应深库位非在库状态,不能移库
                            String deepLoc = Utils.getDeepLoc(slaveProperties, loc.getLocNo());
@@ -2644,68 +2817,69 @@

            if (null == loc) {
                log.error("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
            }
//                throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
            } else {

            // 获取工作号
            int workNo = commonService.getWorkNo(0);
            // 保存工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(new Date());
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(11); // 入出库状态： 11.库格移载
            wrkMast.setIoPri(13D);
            wrkMast.setCrnNo(crn.getId());
            wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
            wrkMast.setLocNo(loc.getLocNo()); // 目标库位
            wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
            wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
            wrkMast.setLinkMis("N");
            wrkMast.setAppeTime(new Date());
            wrkMast.setModiTime(new Date());
            int res = wrkMastMapper.insert(wrkMast);
            if (res == 0) {
                throw new CoolException("保存工作档失败");
            }
            // 工作档明细保存
            if (shallowLoc.getLocSts().equals("F")) {
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
                for (LocDetl locDetl : locDetls) {
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.setWrkNo(workNo);
                    wrkDetl.setIoTime(new Date());
                    wrkDetl.setAnfme(locDetl.getAnfme());
                    VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
                    wrkDetl.setAppeTime(new Date());
                    wrkDetl.setModiTime(new Date());
                    if (!wrkDetlService.insert(wrkDetl)) {
                        throw new CoolException("保存工作档明细失败");
                // 获取工作号
                int workNo = commonService.getWorkNo(0);
                // 保存工作档
                WrkMast wrkMast = new WrkMast();
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(new Date());
                wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
                wrkMast.setIoType(11); // 入出库状态： 11.库格移载
                wrkMast.setIoPri(13D);
                wrkMast.setCrnNo(crn.getId());
                wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
                wrkMast.setLocNo(loc.getLocNo()); // 目标库位
                wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
                wrkMast.setPicking("N"); // 拣料
                wrkMast.setExitMk("N"); // 退出
                wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
                wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
                wrkMast.setLinkMis("N");
                wrkMast.setAppeTime(new Date());
                wrkMast.setModiTime(new Date());
                int res = wrkMastMapper.insert(wrkMast);
                if (res == 0) {
                    throw new CoolException("保存工作档失败");
                }
                // 工作档明细保存
                if (shallowLoc.getLocSts().equals("F")) {
                    List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
                    for (LocDetl locDetl : locDetls) {
                        WrkDetl wrkDetl = new WrkDetl();
                        wrkDetl.setWrkNo(workNo);
                        wrkDetl.setIoTime(new Date());
                        wrkDetl.setAnfme(locDetl.getAnfme());
                        VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制
                        wrkDetl.setAppeTime(new Date());
                        wrkDetl.setModiTime(new Date());
                        if (!wrkDetlService.insert(wrkDetl)) {
                            throw new CoolException("保存工作档明细失败");
                        }
                    }
                }
            }
            // 修改源库位状态
            if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
                shallowLoc.setLocSts("R"); // R.出库预约
                shallowLoc.setModiTime(new Date());
                if (!locMastService.updateById(shallowLoc)) {
                    throw new CoolException("更新源库位状态失败");
                // 修改源库位状态
                if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
                    shallowLoc.setLocSts("R"); // R.出库预约
                    shallowLoc.setModiTime(new Date());
                    if (!locMastService.updateById(shallowLoc)) {
                        throw new CoolException("更新源库位状态失败");
                    }
                } else {
                    throw new CoolException("源库位出库失败");
                }
            } else {
                throw new CoolException("源库位出库失败");
            }
            // 修改目标库位状态
            if (loc.getLocSts().equals("O")) {
                loc.setLocSts("S"); // S.入库预约
                loc.setModiTime(new Date());
                if (!locMastService.updateById(loc)) {
                    throw new CoolException("更新目标库位状态失败");
                // 修改目标库位状态
                if (loc.getLocSts().equals("O")) {
                    loc.setLocSts("S"); // S.入库预约
                    loc.setModiTime(new Date());
                    if (!locMastService.updateById(loc)) {
                        throw new CoolException("更新目标库位状态失败");
                    }
                } else {
                    throw new CoolException("移转失败");
                }
            } else {
                throw new CoolException("移转失败");
            }
        } catch (Exception e) {
            log.error("双深库位阻塞，对浅库位进行移转失败", e);
@@ -4236,7 +4410,7 @@
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1(rgvRunSta[0].shortValue());
                rgvCommand.setSourceStaNo1(rgvRunSta[1].shortValue());
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
@@ -4258,7 +4432,7 @@
                rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
                rgvCommand.setTaskNo2((short)32222); // 工位2工作号
                rgvCommand.setTaskMode2(RgvTaskModeType.X_MOVE); // 工位2任务模式:  回原点
                rgvCommand.setSourceStaNo2(rgvRunSta[1].shortValue());
                rgvCommand.setSourceStaNo2(rgvRunSta[0].shortValue());
                rgvCommand.setCommand((short) 2);   //工位2任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(5, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
@@ -4506,4 +4680,79 @@
        }
    }

    /**
     * 二楼空托回流到一楼，3.站到站任务
     */
    public synchronized void emptyTrayReflux() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            List<WrkMast> wrkMastList = wrkMastMapper.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 2)
                    .eq("crn_no",crn.getId()).eq("io_type", 3));
            for (WrkMast wrkMast : wrkMastList) {
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) {
                    continue;
                }
                if (crnProtocol.getStatusType() == CrnStatusType.IDLE
                        && crnProtocol.getTaskNo() == 0
                        && crnProtocol.getModeType() == CrnModeType.AUTO
                        && crnProtocol.getLoaded() == 0
                        && crnProtocol.getForkPos() == 0) {

                    CrnSlave.CrnStn crnStn = null;
                    CrnSlave.CrnStn crnStn2 = null;
                    for (CrnSlave.CrnStn crnStn1 : crn.getCrnOutStn()){
                        if(crnStn1.getStaNo().equals(wrkMast.getStaNo())){
                            crnStn = crnStn1;
                            break;
                        }
                    }
                    for (CrnSlave.CrnStn crnStn1 : crn.getCrnInStn()){
                        if(crnStn1.getStaNo().equals(wrkMast.getSourceStaNo())){
                            crnStn2 = crnStn1;
                            break;
                        }
                    }
                    if(Cools.isEmpty(crnStn) || Cools.isEmpty(crnStn2)){
                        continue;
                    }

                    // 入库命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(crnStn2.getRow().shortValue());     // 源库位排
                    crnCommand.setSourcePosY(crnStn2.getBay().shortValue());     // 源库位列
                    crnCommand.setSourcePosZ(crnStn2.getLev().shortValue());     // 源库位层
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
//                    crnCommand.setSourceStaNo(crnStn.getPlatNo().shortValue());     // 源库位排
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 2.设备上走 => 3.吊车入库中
                        Date now = new Date();
                        wrkMast.setWrkSts(3L);
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    }
                    break;
                }

            }
        }
    }

    /**
     * 12.跨巷道移库
     */
    public synchronized void autoMoveLoc() {

    }
}