调度方法可通过穿梭车号进行指定车辆调度

Junjie

2023-08-01 2e84db729d434524c7b35939c76c4d7020126167

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

@@ -28,6 +28,7 @@
import com.zy.core.model.protocol.*;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.*;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -959,235 +960,76 @@
     */
    public synchronized void shuttleOutExecute() {
        for (WrkMast wrkMast : wrkMastMapper.selectBy2125()) {
            //提取一条待出库任务
            if (wrkMast != null) {
                String outStaLocNo = null;//出库站点库位号
                //获取出库站点
                for (DevpSlave devpSlave : slaveProperties.getDevp()) {
                    for (DevpSlave.StaRack staOutRack : devpSlave.getRackOutStn()) {
                        if (staOutRack.getStaNo().equals(wrkMast.getStaNo())) {
                            //出库站点和工作档出库站点一致
                            outStaLocNo = CommonUtils.getLocNoFromRBL(staOutRack.getRow(), staOutRack.getBay(), staOutRack.getLev());
                        }
                    }

                }

                if (wrkMast.getWrkSts() == 21
                        || wrkMast.getWrkSts() == 25
                        || wrkMast.getWrkSts() == 31) {
                    ShuttleThread shuttleThread = null;
                    HashMap<String, Object> searchIdleShuttle = null;

                    LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
                    LiftProtocol liftProtocol = liftThread.getLiftProtocol();

                    if (wrkMast.getWrkSts() == 21) {
                        if (wrkMast.getShuttleNo() == null) {
                            //寻找最近且空闲的四向穿梭车
                            searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                            shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                            if (shuttleThread == null) {
                                continue;
                            }
                            wrkMast.setShuttleNo(shuttleThread.getSlave().getId());//给工作档分配四向穿梭车号
                            wrkMastMapper.updateById(wrkMast);
                        }else {
                            //直接使用任务保存中的小车
                            shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                        }
                    }else if(wrkMast.getWrkSts() == 25) {//状态25，需要向小车下发命令从提升机移动出去，需要判断提升机状是否空闲、提升机是否到达目标楼层、目标楼层站点是否存在、目标楼层站点是否给出提升机到位信号

                        //判断提升机是否空闲
                        if (!liftProtocol.isIdleNoTask()) {
                            try {
                                Thread.sleep(1000);//休眠1s
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            continue;//提升机忙
                        }
                        //判断提升机任务号和当前工作档任务号是否一致
                        if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                            continue;
                        }

                        //判断提升机楼层是否到位，判断站点是否给出提升机到位信号
                        String locNo = wrkMast.getSourceLocNo();
                        int lev = Utils.getLev(locNo);//目标二维码所在楼层
                        Short liftLev = liftProtocol.getLev();//提升机所在楼层
                        if (liftLev == null) {//提升机可能在输送线楼层
                            continue;
                        }
                        if (liftLev.intValue() != lev) {
                            continue;//提升机不在目标楼层跳过
                        }

                        Integer staNo = Utils.levToOutInStaNo(lev >= 2 ? lev + 1 : lev);
                        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                        //获取目标站信息
                        StaProtocol staProtocol1 = devpThread.getStation().get(staNo);
                        if (staProtocol1 == null) {
                            continue;//站点信息不存在
                        }
                        if (!staProtocol1.isLiftArrival()) {
                            continue;//站点提升机到位信号false
                        }

                        //继续完成之前小车未完成的任务
                        shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                    } else if (wrkMast.getWrkSts() == 31) {
                        //继续完成之前小车未完成的任务
                        shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                    }

                    if (shuttleThread == null) {
                        continue;
                    }

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

                    if (outStaLocNo == null) {
                        continue;
                    }

                    if (wrkMast.getWrkSts() == 21) {

                        if (!shuttleProtocol.isIdle()) {
                            continue;
                        }

                        //源库位(小车当前位置)
                        String currentLocNo = shuttleProtocol.getCurrentLocNo();

                        //小车当前层高
                        Integer currentLev = Utils.getLev(currentLocNo);
                        //当前楼层提升机输送站点库位号
                        String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

                        ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                        //四向穿梭车号
                        assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                        //任务号
                        assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
                        //入出库模式
                        assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());
                        assignCommand.setSourceLocNo(currentLocNo);

                        //判断小车和库位是否在同一层
                        if (currentLev == Utils.getLev(wrkMast.getSourceLocNo())) {
                            //同一层(将小车移动到货物位置)

                            List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);
                            if (commands == null) {
                                //未找到路径，等待下一次
                                continue;
                            }

                            //分配目标库位
                            shuttleProtocol.setLocNo(wrkMast.getSourceLocNo());
                            //分配任务号
                            shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                            //分配源库位
                            shuttleProtocol.setSourceLocNo(currentLocNo);
                            //目标库位
                            assignCommand.setLocNo(wrkMast.getSourceLocNo());
//                            assignCommand.setCommands(commands);
                            wrkMast.setWrkSts(26L);//小车搬运中

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
                                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                            }
                        }else {
                            //不同层，将目标库位分配成提升机库位号(将小车移动到提升机位置)

                            //小车到提升机口指令
                            List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, ShuttleTaskModeType.PAK_IN.id, assignCommand, shuttleThread);
                            if (commands == null) {
                                if (!currentLocNo.equals(liftSiteLocNo)) {//当前位置也不在提升机口
                                    continue;//未找到路径
                                }
                                commands = new ArrayList<>();
                            }
                            shuttleProtocol.setLocNo(liftSiteLocNo);
                            //分配任务号
                            shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                            //分配源库位
                            shuttleProtocol.setSourceLocNo(currentLocNo);

                            //获取当前小车所在楼层的站点信息
                            BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                            Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

//                            //增加移动进提升机命令
//                            ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1600, ShuttleRunDirection.TOP.id, null, null, 500);
//                            commands.add(moveCommand);

                            //目标库位
                            assignCommand.setLocNo(liftSiteLocNo);
//                            assignCommand.setCommands(commands);
                            wrkMast.setWrkSts(22L);//小车迁移状态

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
                                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 25) {
                        if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                            continue;
                        }

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

                        //当前楼层提升机输送站点库位号
                        String liftSiteLocNo = Utils.levToOutInStaLocNo(liftProtocol.getLev().intValue());

                        ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                        //四向穿梭车号
                        assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                        //任务号
                        assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
                        //入出库模式
                        assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());
                        assignCommand.setSourceLocNo(liftSiteLocNo);

                        List<ShuttleCommand> commands = this.shuttleAssignCommand(liftSiteLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);
                        if (commands == null) {
                            continue;//未找到路径
                        }

//                        //此时车在提升机内部，需要多下达一步指令让车移动到提升机口
//                        short startCode = liftProtocol.getBarcode();//提升机内部二维码
//                        Short distCode = commands.get(0).getStartCodeNum();//目标二维码
//                        //获取移动命令
//                        ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1600, commands.get(0).getRunDirection(), null, null, 500);
//                        commands.add(0, moveCommand);//将该指令添加到队头

                        //分配目标库位
                        shuttleProtocol.setLocNo(wrkMast.getSourceLocNo());
                        //分配任务号
                        shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                        //分配源库位
                        shuttleProtocol.setSourceLocNo(liftSiteLocNo);
                        //目标库位
                        assignCommand.setLocNo(wrkMast.getSourceLocNo());
//                        assignCommand.setCommands(commands);
                        wrkMast.setWrkSts(26L);//小车搬运中

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

                }
            boolean step1 = this.shuttleOutExecuteStep1(wrkMast);//小车搬出库中
            if (!step1) {
                continue;
            }
        }
    }

    /**
     * 出库-小车搬出库中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    public boolean shuttleOutExecuteStep1(WrkMast wrkMast) {
        //21.生成出库任务 => 22.小车搬运中
        if (wrkMast.getWrkSts() == 21) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                return false;
            }

            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                return false;
            }
            if (!shuttleProtocol.isIdle()) {
                return false;
            }

            //获取目标站对应的输送站点
            BasDevp targetBasDevp = basDevpService.selectByLevAndLiftNo(Utils.getLev(wrkMast.getSourceLocNo()), wrkMast.getLiftNo());
            if (targetBasDevp == null) {
                return false;//缺少站点信息
            }

            //判断小车是否到达货物库位
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车不在输送站点位置
                dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在输送站点进行取货
                return false;
            }

            //小车已抵达货物位置，进行搬运货物
            NyShuttleOperaResult result = NyShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), wrkMast.getSourceLocNo(), targetBasDevp.getLocNo());
            if (result == null) {//出库路径计算失败
                return false;
            }

            //创建分配命令
            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());//任务号
            assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
            assignCommand.setCommands(result.getCommands());//运行命令
            assignCommand.setNodes(result.getNodes());//路径节点

            wrkMast.setWrkSts(22L);//21.生成出库任务 => 22.小车搬运中
            wrkMast.setModiTime(new Date());
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
            }
            return false;
        }
        return true;
    }

    /**
@@ -1391,19 +1233,13 @@
                continue;
            }


//            if (!liftProtocol.isIdle()) {
//                continue;
//            }

            //判断提升机是否处于空闲状态，没有判断任务号，可能提升机处于空闲，但是还有任务未完成
            if (!liftProtocol.isIdleNoTask()) {
            if (!liftProtocol.isIdle()) {
                continue;
            }

            //搜索是否有待处理的任务
            List<WrkMast> wrkMasts = wrkMastMapper.selectLiftStep262327();
            if (wrkMasts.size() == 0) {
            List<WrkMast> wrkMasts = wrkMastMapper.selectLiftStep223103();
            if (wrkMasts.isEmpty()) {
                continue;
            }

@@ -1414,243 +1250,142 @@
                    continue;
                }

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

                DevpThread devpThread = null;
                Integer devpId = null;
                for (DevpSlave devp : slaveProperties.getDevp()){
                    // 获取入库站信息
                    devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    devpId = devp.getId();
                boolean stepIn = this.liftIoExecuteStepIn(wrkMast);//提升机入库
                if (!stepIn) {
                    continue;
                }

                if (wrkMast.getWrkSts() == 2) {//2.设备上走
                    if (liftProtocol.getTaskNo().intValue() != 0) {
                        //存在未完成任务号
                        continue;
                    }
//                    if (liftProtocol.getPlatShuttleCheck()) {
//                        //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
//                        continue;
//                    }

                    //获取目标站
                    StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getStaNo());
                    if (staProtocol.isLoading() || !staProtocol.isInEnable()) {//目标站有物，不可入，禁止分配任务
                        continue;
                    }

                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                    Integer levTmp = wrkMastLocNoLey;
                    if (wrkMastLocNoLey >= 2) {
                        levTmp += 1;
                    }
                    Integer distStaNo = Utils.levToOutInStaNo(levTmp);

//                    if (liftProtocol.getPositionArrivalFeedback().intValue() != LiftLevType.TWO.realLev.intValue()) {
//                        //提升机不在输送线楼层，获取到输送线层的提升机命令
//                        LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
//                        commands.add(command1);//将命令添加进list
//                    }

//                    //输送线将货物运进来(无货正转)
//                    LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 3);
//                    command2.setOperaStaNo((short) 102);//操作102站
//                    command2.setRotationDire(1);//给输送线下发链条转动信号，正转
//                    command2.setDevpId(devpId);
//                    command2.setStaNo(distStaNo.shortValue());//设置目标站
//                    commands.add(command2);//将命令添加进list
//
//                    //提升机前往目标楼层(工作档目标楼层)
//                    LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), levTmp);
//                    commands.add(command3);//将命令添加进list
//
//                    //提升机到达指定楼层，输送线将货物移出去(正转)
//                    //输送线将货物移出去
//                    LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 1);
//                    command4.setOperaStaNo(distStaNo.shortValue());//操作目标楼层站点
//                    command4.setRotationDire(1);//给输送线下发链条转动信号，正转
//                    command4.setDevpId(devpId);
//                    command4.setStaNo(distStaNo.shortValue());//设置目标站
//                    commands.add(command4);//将命令添加进list

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(3L);//3.提升机搬运中
                } else if (wrkMast.getWrkSts() == 6) {//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
                    if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                        //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                        continue;
                    }
                    liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号

                    //判断小车是否在提升机内，且处于空闲状态
                    ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                    if (shuttleThread == null) {
                        continue;
                    }
                    ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                    if (shuttleProtocol == null) {
                        continue;
                    }
                    if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                        continue;//小车状态忙
                    }
//                    if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
//                        continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
//                    }
//                    if (!liftProtocol.getPlatShuttleCheck()) {
//                        //提升机未检测到小车，禁止执行
//                        continue;
//                    }

                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                    if (wrkMastLocNoLey >= 2) {
                        wrkMastLocNoLey++;
                    }

//                    //提升机前往目标楼层(工作档目标楼层)
//                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
//                    commands.add(command1);//将命令添加进list

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(7L);//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
                } else if(wrkMast.getWrkSts() == 23) {//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
                    if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                        //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                        continue;
                    }
                    liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号

                    //判断小车是否在提升机内，且处于空闲状态
                    ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                    if (shuttleThread == null) {
                        continue;
                    }
                    ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                    if (shuttleProtocol == null) {
                        continue;
                    }

                    if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                        continue;//小车状态忙
                    }
//                    if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
//                        continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
//                    }
//                    if (!liftProtocol.getPlatShuttleCheck()) {
//                        //提升机未检测到小车，禁止执行
//                        continue;
//                    }

                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getSourceLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                    if (wrkMastLocNoLey >= 2) {
                        wrkMastLocNoLey++;
                    }

//                    //提升机前往目标楼层(工作档目标楼层)
//                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
//                    commands.add(command1);//将命令添加进list

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(24L);//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
                } else if (wrkMast.getWrkSts() == 27) {//27.小车出库搬运完成
                    if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                        //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                        continue;
                    }
//                    if (liftProtocol.getPlatShuttleCheck()) {
//                        //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
//                        continue;
//                    }

                    //工作档源库位号
                    String wrkMastLocNo = wrkMast.getSourceLocNo();
                    //工作档源库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                    //提升机当前楼层
                    int liftLev = liftProtocol.getLev().intValue();

//                    //判断提升机是否到位
//                    StaProtocol staProtocol = devpThread.getStation().get(Utils.levToOutInStaNo(wrkMastLocNoLey >= 2 ? wrkMastLocNoLey + 1 : wrkMastLocNoLey));//起始站点
//                    if (liftLev != wrkMastLocNoLey && !staProtocol.isLiftArrival()) {
//                        //提升机不在工作档源库位楼层，调度提升机
//                        LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
//                        commands.add(command1);//将命令添加进list
//                    }
//
//                    //输送线将货物运进来(无货反转)
//                    LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 4);
//                    command2.setOperaStaNo(staProtocol.getSiteId().shortValue());//输送线操作站点号
//                    command2.setRotationDire(2);//给输送线下发链条转动信号，反转
//                    command2.setDevpId(devpId);//输送线ID
//                    command2.setStaNo((short) 104);//写入出库目标站104
//                    commands.add(command2);//将命令添加进list
//
//                    //提升机前往出库口，输送线楼层
//                    LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
//                    command3.setDevpId(devpId);//输送线ID
//                    commands.add(command3);//将命令添加进list
//
//                    //提升机到达指定楼层，输送线将货物移出去(反转)
//                    //输送线将货物移出去
//                    LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 2);
//                    command4.setOperaStaNo((short) 102);//操作102站
//                    command4.setRotationDire(2);//给输送线下发链条转动信号，反转
//                    command4.setDevpId(devpId);//输送线ID
//                    commands.add(command4);//将命令添加进list
//
//                    //提升机链条执行完毕后，给102站写入资料
//                    LiftCommand command5 = liftThread.getResetCommand();
//                    command5.setDevpId(devpId);//输送线ID
//                    command5.setOperaStaNo((short) 102);//操作102站
//                    command5.setStaNo((short) 104);//写入出库目标站104
//                    command5.setRotationDire(0);//链条转动停止
//                    commands.add(command5);

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(28L);//28.提升机搬运中
                }

                //所需命令组合完毕，更新数据库，提交到线程去工作
                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));
                boolean stepOut = this.liftIoExecuteStepOut(wrkMast);//提升机出库
                if (!stepOut) {
                    continue;
                }
            }

        }
    }

    /**
     * 提升机入库
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean liftIoExecuteStepIn(WrkMast wrkMast) {
        //--------------------------------------提升机入库-----------------------------------------//
        Date now = new Date();

        //2.设备上走 ==> 3.提升机搬运中
        if (wrkMast.getWrkSts() == 2) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                return false;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                return false;
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            //获取源站对应的输送站点
            BasDevp sourceBasDevp = basDevpService.selectById(wrkMast.getSourceStaNo());
            //获取目标站对应的输送站点
            BasDevp targetBasDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (sourceBasDevp == null || targetBasDevp == null) {
                return false;//缺少站点信息
            }

            //获取提升机命令
            NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftProtocol.getLiftNo().intValue(), NyLiftTaskModelType.MOVE_TRAY.id, sourceBasDevp.getDevNo(), targetBasDevp.getDevNo(), wrkMast.getWrkNo());

            ArrayList<NyLiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_TRAY.id.shortValue());

            wrkMast.setWrkSts(3L);//2.设备上走 ==> 3.提升机搬运中
            wrkMast.setLiftNo(liftThread.getSlave().getId());//任务档绑定提升机号
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
            }

            return false;
        }
        return true;
    }

    /**
     * 提升机出库
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean liftIoExecuteStepOut(WrkMast wrkMast) {
        //--------------------------------------提升机出库-----------------------------------------//
        Date now = new Date();

        //23.小车搬运完成 ==> 24.提升机搬运中
        if (wrkMast.getWrkSts() == 23) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                return false;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                return false;
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            //获取源站对应的输送站点
            BasDevp sourceBasDevp = basDevpService.selectByLevAndLiftNo(Utils.getLev(wrkMast.getSourceLocNo()), liftProtocol.getLiftNo().intValue());
            //获取目标站对应的输送站点
            BasDevp targetBasDevp = basDevpService.selectById(wrkMast.getSourceStaNo());
            if (sourceBasDevp == null || targetBasDevp == null) {
                return false;//缺少站点信息
            }

            //获取提升机命令
            NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftProtocol.getLiftNo().intValue(), NyLiftTaskModelType.MOVE_TRAY.id, sourceBasDevp.getDevNo(), targetBasDevp.getDevNo(), wrkMast.getWrkNo());

            ArrayList<NyLiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_TRAY.id.shortValue());

            wrkMast.setWrkSts(24L);//23.小车搬运完成 ==> 24.提升机搬运中
            wrkMast.setLiftNo(liftThread.getSlave().getId());//任务档绑定提升机号
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
            }

            return false;
        }
        return true;
    }

    /**
@@ -1677,6 +1412,7 @@
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 3://3.提升机搬运中 ==> 4.提升机搬运完成
                            wrkMast.setWrkSts(4L);
                            wrkMast.setLiftNo(null);//释放提升机
                            break;
                        case 24://24.提升机搬运中 ==> 25.提升机搬运完成
                            wrkMast.setWrkSts(25L);
@@ -2619,6 +2355,13 @@
    }

    /**
     * 调度车辆-调度指定穿梭车
     */
    public void dispatchShuttle(Integer wrkNo, String locNo, Integer shuttleNo) {
        shuttleMoveGenerate(wrkNo, locNo, shuttleNo);
    }

    /**
     * 调度车辆
     */
    public void dispatchShuttle(Integer wrkNo, String locNo) {
@@ -2985,6 +2728,7 @@
            assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_CAR.id.shortValue());

            wrkMast.setWrkSts(104L);//提升机搬运中  103.小车到提升机完成 ==> 104.提升机搬运中
            wrkMast.setLiftNo(liftThread.getSlave().getId());//锁定提升机防止被占用
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务