提升机代码，四向穿梭车线程优化

Junjie

2023-03-31 87c4efe93e6fe31a9c989b4aa5cc0c8f559b845d

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

@@ -4,20 +4,17 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
import com.zy.common.model.StartupDto;
import com.zy.common.model.*;
import com.zy.common.model.enums.WrkChargeType;
import com.zy.common.service.CommonService;
import com.zy.common.service.erp.ErpService;
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.*;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.News;
@@ -25,17 +22,10 @@
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.*;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.command.LedCommand;
import com.zy.core.model.command.SteCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.model.protocol.SteProtocol;
import com.zy.core.model.command.*;
import com.zy.core.model.protocol.*;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.LedThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.core.thread.SteThread;
import com.zy.core.thread.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -95,6 +85,8 @@
    private OrderMapper orderMapper;
    @Autowired
    private OrderDetlMapper orderDetlMapper;
    @Autowired
    private RedisUtil redisUtil;

    /**
     * 组托
@@ -114,59 +106,51 @@
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "异常：";
                if (staProtocol.isFrontErr()) {
                    errMsg = errMsg+"前超限；";
                    back = true;
                }
                if (staProtocol.isBackErr()) {
                    errMsg = errMsg+"后超限";
                    back = true;
                }
                if (staProtocol.isHighErr()) {
                    errMsg = errMsg+"高超限";
                    back = true;
                }
                if (staProtocol.isLeftErr()) {
                    errMsg = errMsg+"左超限";
                    back = true;
                }
                if (staProtocol.isRightErr()) {
                    errMsg = errMsg+"右超限";
                    back = true;
                }
                if (staProtocol.isWeightErr()) {
                    errMsg = errMsg+"超重";
                    back = true;
                }
                if (staProtocol.isBarcodeErr()) {
                    errMsg = errMsg+"扫码失败";
                    back = true;
                }
                // 退回
                if (back) {
                    // led 异常显示
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    if (ledThread != null) {
                        MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
                    }
                    continue;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999))
                        && staProtocol.isPakMk()) {

                    // 尺寸检测异常
                    boolean back = false;
                    String errMsg = "";
                    if (staProtocol.isFrontErr()) {
                        errMsg = "前超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "高超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重";
                        back = true;
                    }
                    if (!back && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码失败";
                        back = true;
                    }

                    // 退回
                    if (back) {
                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                        staProtocol.setWorkNo((short) 32002);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        // led 异常显示
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                        if (ledThread != null) {
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
                        }
                        continue;
                    }

                    // 获取条码扫描仪信息
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
@@ -176,7 +160,7 @@
                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
//                        News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)|| "00000000".equals(barcode)) {
                            staProtocol.setWorkNo((short) 32002);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
@@ -407,7 +391,6 @@
                    if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) {
                        wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
                        if (null == wrkMast) {
                            News.error("{}任务号错误，暂无拣料任务！", staProtocol.getWorkNo());
                            continue;
                        }
                    } else {
@@ -620,6 +603,391 @@
    }

    /**
     * 入出库  ===>>  四向穿梭车入出库作业下发
     */
    public synchronized void shuttleIoExecute() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库站
            for (DevpSlave.StaRack rackInStn : devp.getRackInStn()) {
                // 获取入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());

                StaProtocol staProtocol = devpThread.getStation().get(rackInStn.getStaNo());
                StaProtocol staProtocol105 = devpThread.getStation().get(105);
                staProtocol105.setWorkNo((short) 752);
                staProtocol105.setStaNo((short) 100);

                StaProtocol staProtocol106 = devpThread.getStation().get(106);
                staProtocol106.setWorkNo((short) 753);
                staProtocol106.setStaNo((short) 100);

                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();

                // 判断是否满足入库条件
                if (true || staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()) {
                    WrkMast wrkMast = wrkMastMapper.selectRackInStep48(workNo, staProtocol.getSiteId());
                    if (wrkMast != null) {
                        if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 8) {
                            ShuttleThread shuttleThread = null;
                            HashMap<String, Object> searchIdleShuttle = null;
                            if (wrkMast.getWrkSts() == 4) {
                                //寻找最近且空闲的四向穿梭车
                                searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                                shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                            }else {
                                //状态8，四向穿梭车已在提升机口，等待命令进行入库搬运动作
                                Integer shuttleNo = wrkMast.getShuttleNo();//四向穿梭车号
                                shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
                            }

                            if (shuttleThread == null) {
                                continue;
                            }

                            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                            if (!shuttleProtocol.isIdle()) {
                                continue;
                            }

                            wrkMast.setShuttleNo(shuttleProtocol.getShuttleNo().intValue());//给工作档分配四向穿梭车号

                            //分配任务号
                            shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                            //分配源库位
                            shuttleProtocol.setSourceLocNo(wrkMast.getSourceLocNo());

                            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                            //四向穿梭车号
                            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                            //任务号
                            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
                            //入出库模式
                            assignCommand.setTaskMode(ShuttleTaskModeType.PAK_IN.id.shortValue());
                            //源库位(小车当前位置)
                            String currentLocNo = shuttleProtocol.getCurrentLocNo();
                            assignCommand.setSourceLocNo(currentLocNo);

                            if (wrkMast.getWrkSts() == 8 || Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
                                //同一层
                                //分配目标库位
                                shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                //目标库位
                                assignCommand.setLocNo(wrkMast.getLocNo());
                                wrkMast.setWrkSts(9L);//小车入库中
                            }else {
                                //不同层，将目标库位分配成提升机库位号

                                //小车当前层高
                                Integer currentLev = Integer.parseInt(currentLocNo.substring(currentLocNo.length() - 2, currentLocNo.length()));

                                //获取提升机
                                LiftSlave liftSlave = slaveProperties.getLift().get(0);
                                //提升机库位号
                                String liftLocNo = liftSlave.getLiftLocNo(currentLev);
                                shuttleProtocol.setLocNo(liftLocNo);
                                //目标库位
                                assignCommand.setLocNo(liftLocNo);
                                wrkMast.setWrkSts(5L);//小车迁移状态
                            }

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
                                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                            }
                        }

                    }
                }

            }
        }

    }

    /**
     * 搜索空闲且最近的四向穿梭车
     */
    public HashMap<String,Object> searchIdleShuttle(WrkMast wrkMast) {
        HashMap<String, Object> map = new HashMap<>();
        String locNo = wrkMast.getWrkSts() < 10 ? wrkMast.getLocNo() : wrkMast.getSourceLocNo();//库位号
        LocMast locMast = locMastService.queryByLoc(locNo);//找到库位记录
        String lay = locNo.substring(locNo.length() - 2, locNo.length());//当前工作档库位层高
        ShuttleThread recentShuttle = null;//当前距离最近的四向穿梭车线程

        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }
            if (!shuttleProtocol.isIdle()) {
                continue;
            }

            String shuttleLocNo = shuttleProtocol.getCurrentLocNo();//二维码对应库位号
            String shuttleLocNoLay = shuttleLocNo.substring(shuttleLocNo.length() - 2, shuttleLocNo.length());//库位号对应层高
            if (lay.equals(shuttleLocNoLay)) {
                //当前四向穿梭车和工作档任务在同一层，则调配该车辆
                map.put("sameLay", true);//同一层
                map.put("result", shuttleThread);
                return map;
            }

            //更新当前最近的四向穿梭车
            if (recentShuttle == null) {
                recentShuttle = shuttleThread;
            }else {
                ShuttleProtocol recentShuttleProtocol = recentShuttle.getShuttleProtocol();//目前最近穿梭车
                String recentShuttleLocNo = recentShuttleProtocol.getCurrentLocNo();//二维码对应库位号
                String recentShuttleLocNoLay = recentShuttleLocNo.substring(recentShuttleLocNo.length() - 2, recentShuttleLocNo.length());//库位号对应层高

                int recentShuttleLocNoLayInt = Integer.parseInt(recentShuttleLocNoLay);
                int layInt = Integer.parseInt(lay);
                int shuttleLocNoLayInt = Integer.parseInt(shuttleLocNoLay);
                int i = Math.abs(layInt - recentShuttleLocNoLayInt);//工作档楼层减最近穿梭车楼层，取绝对值
                int j = Math.abs(layInt - shuttleLocNoLayInt);//工作档楼层减当前穿梭车楼层，取绝对值
                if (i < j) {
                    //更新最近穿梭车
                    recentShuttle = shuttleThread;
                } else if (i == j) {
                    //楼层相同情况
                    //找距离出库点最近的车

                    if (!(recentShuttleProtocol.isIdle() && shuttleProtocol.isIdle())) {
                        //只要有一辆车不是空闲则不进行调度
                        map.put("sameLay", false);//不同层
                        map.put("result", null);
                        return map;
                    }

                    //获取提升机
                    LiftSlave liftSlave = slaveProperties.getLift().get(0);
                    //提升机库位号
                    String recentLiftLocNo = liftSlave.getLiftLocNo(recentShuttleLocNoLayInt);
                    String shuttleLiftLocNo = liftSlave.getLiftLocNo(shuttleLocNoLayInt);

                    //当前最近四向穿梭车到提升机路径
                    List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentShuttleLocNo, recentLiftLocNo, ShuttleTaskModeType.PAK_IN.id);
                    //当前楼层四向穿梭车到提升机路径
                    List<NavigateNode> shuttlePath = NavigateUtils.calc(shuttleLocNo, shuttleLiftLocNo, ShuttleTaskModeType.PAK_IN.id);
                    //判断哪一个路径最短
                    if (shuttlePath.size() < recentShuttlePath.size()) {
                        //如果当前楼层的车路径更小，则更新最近穿梭车
                        recentShuttle = shuttleThread;
                    }
                }
            }
        }

        map.put("sameLay", false);//不同层
        map.put("result", recentShuttle);
        return map;
    }

    /**
     * 四向穿梭车任务完成
     */
    public synchronized void shuttleFinished() {
        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车信息
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }

            //四向穿梭车状态为等待确认
            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id && shuttleProtocol.getTaskNo() != 0) {
                //将任务档标记为完成
                WrkMast wrkMast = wrkMastMapper.selectByWorkNo59(shuttleProtocol.getTaskNo().intValue());
                if (wrkMast != null) {
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 9:
                            wrkMast.setWrkSts(14L);
                            break;
                        case 5:
                            wrkMast.setWrkSts(6L);
                            break;
                        default:
                    }

                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        //设置四向穿梭车为空闲状态
                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                        //任务号清零
                        shuttleProtocol.setTaskNo((short) 0);
                        //源库位清零
                        shuttleProtocol.setSourceLocNo(null);
                        //目标库位清零
                        shuttleProtocol.setLocNo(null);
                        //标记复位
                        shuttleProtocol.setPakMk(true);
                        //任务指令清零
                        shuttleProtocol.setAssignCommand(null);
                        News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                    } else {
                        News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                    }
                }

            }
        }
    }

    /**
     * 提升机任务
     */
    public synchronized void liftIoExecute() {
        for (LiftSlave liftSlave : slaveProperties.getLift()) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
            if (liftThread == null) {
                continue;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                continue;
            }

            //判断提升机是否处于空闲状态
            if (!liftProtocol.isIdle()) {
                continue;
            }

            //搜索是否有待处理的任务
            WrkMast wrkMast = wrkMastMapper.selectLiftStep6();
            if (wrkMast == null) {
                continue;
            }

            //给提升机分配任务
            liftProtocol.setLiftLock(true);//锁定提升机
            liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
            liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号
            liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

            //找到四向穿梭车的线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, liftProtocol.getShuttleNo().intValue());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }

            //命令list
            ArrayList<LiftCommand> commands = new ArrayList<>();

            //当前穿梭车库位号
            String currentLocNo = shuttleProtocol.getCurrentLocNo();
            //当前穿梭车楼层
            int currentLocNoLey = Integer.parseInt(currentLocNo.substring(currentLocNo.length() - 2, currentLocNo.length()));

            //工作档目标库位号
            String wrkMastLocNo = wrkMast.getLocNo();
            //工作档目标库位楼层
            int wrkMastLocNoLey = Integer.parseInt(wrkMastLocNo.substring(wrkMastLocNo.length() - 2, wrkMastLocNo.length()));

            //提升机当前楼层
            int liftLev = liftProtocol.getLev().intValue();
            if (liftLev != currentLocNoLey) {
                //不同楼层
                LiftCommand command1 = new LiftCommand();
                command1.setLiftNo(liftProtocol.getLiftNo());//提升机号
                command1.setTaskNo(liftProtocol.getTaskNo());//任务号
                command1.setRun((short) 1);//升降
                command1.setDistPosition((short) currentLocNoLey);//目标楼层(穿梭车所在楼层)
                command1.setLiftLock(true);//锁定提升机

                commands.add(command1);//将命令添加进list
            }

            //输送线将四向穿梭车移动进来
            LiftCommand command2 = new LiftCommand();
            command2.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command2.setTaskNo(liftProtocol.getTaskNo());//任务号
            command2.setRun((short) 6);//输送线运作
            command2.setLiftLock(true);//锁定提升机

            commands.add(command2);//将命令添加进list

            //提升机搬运四向穿梭车
            LiftCommand command3 = new LiftCommand();
            command3.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command3.setTaskNo(liftProtocol.getTaskNo());//任务号
            command3.setRun((short) 1);//升降
            command3.setDistPosition((short) wrkMastLocNoLey);//工作档目标楼层
            command3.setLiftLock(true);//锁定提升机

            commands.add(command3);//将命令添加进list

            //提升机到达指定楼层，输送线将四向穿梭车移出去
            //输送线将四向穿梭车移动进来
            LiftCommand command4 = new LiftCommand();
            command4.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command4.setTaskNo(liftProtocol.getTaskNo());//任务号
            command4.setRun((short) 3);//输送线运作
            command4.setLiftLock(true);//锁定提升机

            commands.add(command4);//将命令添加进list

            wrkMast.setWrkSts(7L);//移动任务
            //所需命令组合完毕，更新数据库，提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo());
            assignCommand.setTaskNo(liftProtocol.getTaskNo());
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
            }
        }
    }

    /**
     * 提升机任务完成
     */
    public synchronized void liftFinished() {
        for (LiftSlave liftSlave : slaveProperties.getLift()) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                continue;
            }

            //提升机为等待确认
            if (liftProtocol.getProtocolStatus() == LiftProtocolStatusType.WAITING.id && liftProtocol.getTaskNo() != 0) {
                //将任务档标记为完成
                WrkMast wrkMast = wrkMastMapper.selectByWorkNo7(liftProtocol.getTaskNo().intValue());
                if (wrkMast != null) {
                    wrkMast.setWrkSts(8L);
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        //设置提升机为空闲状态
                        liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
                        //任务号清零
                        liftProtocol.setTaskNo((short) 0);
                        //标记复位
                        liftProtocol.setPakMk(true);
                        //任务指令清零
                        liftProtocol.setAssignCommand(null);
                        News.info("提升机已确认且任务完成状态,复位。提升机号={}", liftProtocol.getLiftNo());
                    } else {
                        News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
                    }
                }
            }
        }
    }

    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecute(){
@@ -666,7 +1034,7 @@
                // 库位移转
//                this.locToLoc(crn, crnProtocol);
                // 演示
                this.steMoveDemo(crn, crnProtocol);
//                this.steMoveDemo(crn, crnProtocol);
            }
        }
    }
@@ -726,6 +1094,51 @@
                continue;
            }

            List<LocMast> locMasts = null;
            boolean sign=false;
            if (locMast.getRow1()>=5){
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
                        .eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>locMast.getRow1()){
                        if (!locMast1.getLocSts().equals("F") && !locMast1.getLocSts().equals("D")){
                            if (!locMast1.getLocSts().equals("X")){
                                sign=true;
                                break;
                            }
                        }
                    }else if (locMast1.getRow1()<locMast.getRow1()){
                        if (locMast1.getLocSts().equals("F") || locMast1.getLocSts().equals("D")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }else {
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
                        .eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>locMast.getRow1()){
                        if (locMast1.getLocSts().equals("F") || locMast1.getLocSts().equals("D")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }else if (locMast1.getRow1()<locMast.getRow1()){
                        if (!locMast1.getLocSts().equals("F") && !locMast1.getLocSts().equals("D")){
                            if (!locMast1.getLocSts().equals("X")){
                                sign=true;
                                break;
                            }
                        }
                    }
                }
            }
            if (sign){
                continue;
            }

            // 检测是否存在出库任务
            if (null != wrkMastMapper.selectPakout(slave.getId(), null)) {
                News.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
@@ -733,7 +1146,9 @@
            }

            // 置顶任务
            wrkMast.setIoPri((double) 9999);
            if (wrkMast.getIoPri()<8000){
                wrkMast.setIoPri(wrkMast.getIoPri()+9000d);
            }
            wrkMastMapper.updateById(wrkMast);

                // 目标库位 ===>> 最外层库位
@@ -899,6 +1314,36 @@
                News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                continue;
            }
            List<LocMast> locMasts = null;
            boolean sign=false;
            if (sourceSta.getRow1()>=5){
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
                        .eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()<sourceSta.getRow1()){
                        if (!locMast1.getLocSts().equals("O")){
                            News.error("当前工作档源库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }else {
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
                        .eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>sourceSta.getRow1()){
                        if (!locMast1.getLocSts().equals("O")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }
            if (sign){
                continue;
            }

            // 同库位组进行校验
            List<String> groupLocNo = Utils.getGroupLocNo(wrkMast.getSourceLocNo());
@@ -948,7 +1393,9 @@
                }

                // 置顶任务
                wrkMast.setIoPri((double) 9998);
                if (wrkMast.getIoPri()<8000){
                    wrkMast.setIoPri(wrkMast.getIoPri()+8999d);
                }
                wrkMastMapper.updateById(wrkMast);

                // 最外层库位，直接堆垛机出库
@@ -1244,7 +1691,7 @@
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (!steProtocol.isIdle()) { continue; }
            if (steProtocol.getRow() == 1) { continue; }
//            if (steProtocol.getRow() == 1) { continue; }
            String locNo = wrkMast.getWrkSts() < 10 ? wrkMast.getLocNo() : wrkMast.getSourceLocNo();
            // 如果在同一个库位组
            if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), true))
@@ -1613,6 +2060,17 @@
                    WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
                    if (wrkCharge == null) {
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        wrkMast = wrkMastMapper.selectCrnWaiting2(crnProtocol.getTaskNo().intValue());
                        if (wrkMast.getIoType() != 11) {
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                News.error("堆垛机处于等待确认且任务完成状态,复位，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                            } else {
                                News.error("堆垛机处于等待确认且任务完成状态,复位失败，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                            }
                        }
                        continue;
                    } else {
                        // 小车搬至指定库位完成
@@ -1835,6 +2293,22 @@
                            }
                        }
                        // 移库 ===>> 堆垛机搬至目标库位组 完成
                    } else if (wrkMast.getWrkSts() == 16) {
                        // 16.吊车出库中 ==> 17.出库完成
                        wrkMast.setWrkSts(17L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                        Integer outCrnNo = locMastService.getOutCrnNo(locMast);
                        wrkMast.setCrnNo(outCrnNo);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                        } else {
                            News.error("修改工作档状态 16.吊车出库中 ==> 17.出库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    }
                }
            }
@@ -1879,15 +2353,17 @@
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 29) {
                                // 29.开始充电 ===>> 30.完成充电
                                wrkCharge.setWrkSts(30L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 32) {
                            }
//                            else if (wrkCharge.getWrkSts() == 29) {
//                                // 29.开始充电 ===>> 30.完成充电
//                                wrkCharge.setWrkSts(30L);
//                                if (!wrkChargeService.updateById(wrkCharge)) {
//                                    News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
//                                } else {
//                                    steThread.setResetFlag(true);
//                                }
//                            }
                            else if (wrkCharge.getWrkSts() == 32) {
                                // 32.小车走行 ===>> 33.小车待搬
                                wrkCharge.setWrkSts(33L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
@@ -2366,18 +2842,11 @@
                        break;
                }
                ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
                ledCommand.setLocNo(wrkMast.getLocNo());
                ledCommand.setStaNo(wrkMast.getStaNo());
                if (wrkMast.getIoType() != 110) {
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    try {
                        WrkDetl wrkDetl = wrkDetls.get(0);
                        if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                            OrderDetl orderDetl = orderDetlMapper.selectItemNoneOfBatch(wrkDetl.getOrderNo(), wrkDetl.getMatnr());
                            ledCommand.getMatDtos().add(new MatDto(orderDetl));
                        }
                    } catch (Exception e) {
                        News.error("led execute fail", e);
                    }
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(),wrkDetl.getSpecs())));
                }
                commands.add(ledCommand);
            }
@@ -2390,9 +2859,20 @@
            }
            // 命令下发 -------------------------------------------------------------------------------
            if (!commands.isEmpty()) {
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    continue;
                if (led.getId()>3){
                    if (!MessageQueue.offer(SlaveType.Led, led.getId()-3, new Task(1, commands))) {
                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId()-3, led.getIp(), led.getPort());
                        continue;
                    }else {
                        ledThread.setLedMk(false);
                    }
                }else {
                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                        continue;
                    }else {
                        ledThread.setLedMk(false);
                    }
                }
            }

@@ -2422,6 +2902,35 @@
     */
    public void ledReset() {
        for (LedSlave led : slaveProperties.getLed()) {

            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
            // 命令集合
            boolean reset = true;
            for (Integer staNo : led.getStaArr()) {
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                }
                if (staProtocol.getWorkNo() != 0 && staProtocol.isLoading()) {
                    reset = false;
                    break;
                }
            }
            // 获取led线程
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
            // led显示默认内容
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(4, new ArrayList<>()))) {
                    News.error(" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                } else {

                }
            }
        }
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
            // 命令集合
@@ -2436,9 +2945,10 @@
                }
            }
            // 获取led线程
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getDevpPlcId());
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
            // led显示默认内容
            if (reset) {
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                }
@@ -2451,6 +2961,9 @@
     */
    @SuppressWarnings("serial")
    public synchronized void loopSteCharge() {
        if (!Cools.isEmpty(wrkMastMapper.selectAllC())){
            return;
        }
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) {
            return;
        }
@@ -2486,7 +2999,7 @@
                    SteChargeType steCharge = null;
                    do {
                        String locNo;
                        if (!devpThread.charge0) {
                        if (devpThread.charge0) {
                            SteChargeType first = SteChargeType.FIRST;
                            locNo = first.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null
@@ -2537,14 +3050,14 @@
                    }

                    // 处于充电库位组
                    if (steProtocol.getRow().intValue() == Utils.getRow(chargeLocNo)
                    if ( 0<steProtocol.getRow().intValue() && steProtocol.getRow().intValue()<=4
                            && steProtocol.getBay().intValue() == Utils.getBay(chargeLocNo)
                            && steProtocol.getLev().intValue() == Utils.getLev(chargeLocNo)) {
                        // 修改工作档状态 21.准备充电 => 28.充电就绪
                        wrkCharge.setWrkSts(28L);
                        // 修改工作档状态 21.准备充电 => 24.小车到达
                        wrkCharge.setWrkSts(24L);
                        wrkCharge.setModiTime(new Date());
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            News.error("修改充电任务状态 21.准备充电 => 28.充电就绪 失败！！，工作号={}", wrkCharge.getWrkNo());
                            News.error("修改充电任务状态 21.准备充电 => 24.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    } else {
                        this.letCarBeWaiting(wrkCharge, ste.getId());
@@ -2564,10 +3077,26 @@
     */
    public synchronized void executeSteCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        if (null == wrkCharge) { return; }
        Integer steNo = wrkCharge.getSteNo();
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, 1);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (null == wrkCharge) {
            try{
                if (steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()){
                    SteCommand steCommand = new SteCommand();
                    steCommand.setSteNo(1); // 穿梭车编号
                    steCommand.setTaskNo(10060); // 工作号
                    steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                    if (!MessageQueue.offer(SlaveType.Ste, 1, new Task(2, steCommand))) {
                        News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                    }
                }
            }catch (Exception e){
                return;
            }
            return;
        }
        Integer steNo = wrkCharge.getSteNo();

        BasSte basSte = basSteService.selectById(steNo);
        if (Cools.isEmpty(steProtocol, basSte)) { return; }
        if (steProtocol.getMode() == 0
@@ -2581,9 +3110,35 @@
        if (!steProtocol.isEnable()) {
            return;
        }
        if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
        if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())+40) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
            wrkCharge.setWrkSts(30L);
            wrkChargeMapper.updateById(wrkCharge);
            if (!wrkChargeService.updateById(wrkCharge)) {
                News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
            }else {
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                }
            }
            return;
        }else if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine()) && steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
            wrkCharge.setWrkSts(30L);
            if (!wrkChargeService.updateById(wrkCharge)) {
                News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
            }else {
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                }
            }
            return;
        }
        try {
@@ -2600,49 +3155,39 @@
                    return;
                }

                LocMast locMast = locMastService.selectById(basSte.getIdleLoc());

                // 搬小车至小车走向通道
                List<String> channel = slaveProperties.getChannel();
                for (String channelLocNo : channel) {
                    Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
                    if (null != otherSte) {
                        News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) { return; }
                // 只有当堆垛机空闲 并且 无任务时才继续执行
                if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        LocMast channelLoc = locMastService.selectById(channelLocNo);

                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                        CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                        if (crnProtocol == null) { continue; }
                        // 只有当堆垛机空闲 并且 无任务时才继续执行
                        if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                            // 堆垛机命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                            crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), true).shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改穿梭车运行中排列层
                                steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
                                // 修改工作档状态 22.小车待搬 => 23.吊车搬运
                                Date now = new Date();
                                wrkCharge.setWrkSts(23L);
                                wrkCharge.setCrnStrTime(now);
                                wrkCharge.setModiTime(now);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改工作档状态 22.小车待搬 => 23.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                            break;
                        // 修改穿梭车运行中排列层
                        steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
                        // 修改工作档状态 22.小车待搬 => 23.吊车搬运
                        Date now = new Date();
                        wrkCharge.setWrkSts(23L);
                        wrkCharge.setCrnStrTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            News.error("修改工作档状态 22.小车待搬 => 23.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }

                    }
                }

@@ -2654,7 +3199,7 @@
                    SteCommand steCommand = new SteCommand();
                    steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                    steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                    steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN);  // 去右端
                    steCommand.setTaskMode(SteTaskModeType.BACK_ORIGIN);  // 去右端

                    steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
                    steCommand.setBay(steProtocol.getBay());
@@ -2673,49 +3218,7 @@
                    }
                }
            } else if (wrkCharge.getWrkSts() == 26) {
                // 固定堆垛机
                int crnNo = 1;
                // 入出库任务优先
                if (null != wrkMastMapper.selectWorkingByCrn(crnNo)) {
                    return;
                }

                // 充电位
                LocMast chargeLoc = locMastService.selectById(wrkCharge.getLocNo());

                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) { return; }
                // 只有当堆垛机空闲 并且 无任务时才继续执行
                if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(crnNo); // 堆垛机编号
                    crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
                    } else {
                        // 修改穿梭车运行中排列层
                        steThread.modifyPos(chargeLoc.getRow1(), chargeLoc.getBay1(), chargeLoc.getLev1());
                        // 修改工作档状态 26.等待充电 => 27.放至充电位
                        Date now = new Date();
                        wrkCharge.setWrkSts(27L);
                        wrkCharge.setCrnStrTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            News.error("修改工作档状态 26.等待充电 => 27.放至充电位 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    }
                }
            } else if (wrkCharge.getWrkSts() == 28L) {
                //26.等待充电 ===>
                // 穿梭车下发充电任务
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
@@ -2728,6 +3231,27 @@
                    wrkCharge.setWrkSts(29L);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        News.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }
                }
            } else if (wrkCharge.getWrkSts() == 29) {
                Float idle2 = steProtocol.isIdle2();
                String chargeLine = SpringUtils.getBean(BasSteService.class).selectById(1).getChargeLine();
                if (idle2<(Float.parseFloat(chargeLine)+2)){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 666));//充电标记
                }else if (idle2 >= 100f){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
                    // 29.开始充电 ===>> 30.完成充电
                    wrkCharge.setWrkSts(30L);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }else {
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                        steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                        if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                            News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                        }
                    }
                }
            }
@@ -3254,6 +3778,63 @@
        }

    }
    /**
     * 出入库模式切换
     */
    public synchronized void outAndIn() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    Thread.sleep(500);
                    boolean a=true,b=true;
                    List<WrkMast> wrkMasts = wrkMastMapper.selectAll(inSta.getStaNo());
                    if (Cools.isEmpty(wrkMasts)){
                        b=false;
                    }else {
                        for (WrkMast wrkMast:wrkMasts){
                            if (wrkMast.getSourceStaNo() > wrkMast.getStaNo()){
                                a=false;
                                break;
                            }
                        }
                    }
                    switch (inSta.getStaNo()) {
                        case 102://1F
                            if (a && b){
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 11));
                            }else if (b){
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 12));
                            }else {
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 10));
                            }
                            break;
                        case 202://2F
                            if (a && b){
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 21));
                            }else if (b){
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 22));
                            }else {
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 20));
                            }
                            break;
                        case 302://3F
                            if (a && b){
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 31));
                            }else if (b){
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 32));
                            }else {
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 30));
                            }
                            break;
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}