fixed

Junjie

2023-07-01 ee5e6e5d4714358de0371f83d02739cb765b4dbf

fixed

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

New file
@@ -0,0 +1,222 @@
package com.zy.asrs.controller;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.annotations.ManagerAuth;
import com.core.common.Cools;
import com.core.common.R;
import com.zy.asrs.domain.vo.PlcErrorTableVo;
import com.zy.asrs.domain.vo.SiteTableVo;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasSte;
import com.zy.asrs.entity.WrkCharge;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasSteService;
import com.zy.asrs.service.WrkChargeService;
import com.zy.common.model.enums.WrkChargeType;
import com.zy.common.service.CommonService;
import com.zy.core.DevpThread;
import com.zy.core.News;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.SteChargeType;
import com.zy.core.enums.SteStatusType;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.Task;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.model.protocol.SteProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.core.thread.SteThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/**
 * 输送设备接口
 * Created by vincent on 2020-06-01
 */
@Slf4j
@RestController
@RequestMapping("/site")
public class SiteController {

    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private WrkChargeService wrkChargeService;
    @Autowired
    private BasSteService basSteService;
    @Autowired
    private CommonService commonService;

    @GetMapping("/io/mode/info/site")
    @ManagerAuth(memo = "充电模式")
    public R ioMode(){
        List<Map<String, Object>> res = new ArrayList<>();
        for (DevpSlave devp : slaveProperties.getDevp()) {
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            Map<String, Object> map1 = new HashMap<>();
            map1.put("floor", 1);
            map1.put("modeVal", !devpThread.charge0);
            map1.put("modeDesc", !devpThread.charge0?"充电中":"关闭");
            res.add(map1);
            Map<String, Object> map2 = new HashMap<>();
            map2.put("floor", 2);
            map2.put("modeVal", devpThread.charge1);
            map2.put("modeDesc", devpThread.charge1?"充电中":"关闭");
            res.add(map2);
        }
        return R.ok().add(res);
    }

    @PostMapping("/table/site")
    @ManagerAuth(memo = "站点信息表")
    public R siteTable(){
        List<SiteTableVo> list = new ArrayList<>();
        // 内存数据
        Map<Integer, StaProtocol> station = new HashMap<>();
        for (DevpSlave devp : slaveProperties.getDevp()) {
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            station.putAll(devpThread.getStation());
        }
        // 持久数据
        List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<BasDevp>().orderBy("dev_no"));
        for (BasDevp devp : basDevps) {
            SiteTableVo vo = new SiteTableVo();
            vo.setDevNo(devp.getDevNo());    // 站点编号
            list.add(vo);
            StaProtocol staProtocol = station.get(devp.getDevNo());
            if (null == staProtocol) { continue; }
            vo.setWorkNo(staProtocol.getWorkNo());   //  工作号
            vo.setAutoing(staProtocol.isAutoing()?"Y":"N");     //  自动
            vo.setLoading(staProtocol.isLoading()?"Y":"N");     // 有物
            vo.setInEnable(staProtocol.isInEnable()?"Y":"N");   // 可入
            vo.setOutEnable(staProtocol.isOutEnable()?"Y":"N"); // 可出
            vo.setLiftArrival(staProtocol.isLiftArrival()?"Y":"N"); // 提升机到位信号
            vo.setShuttleTakeEnable(staProtocol.isShuttleTakeEnable()?"Y":"N"); // 穿梭车可取信号
            vo.setPakMk(staProtocol.isPakMk()?"Y":"N");       // 入库标记
            vo.setEmptyMk(staProtocol.isEmptyMk()?"Y":"N");     // 空板信号
            vo.setStaNo(staProtocol.getStaNo());                // 目标站
        }
        return R.ok().add(list);
    }

    @PostMapping("/table/plc/errors")
    @ManagerAuth(memo = "输送设备plc异常信息表")
    public R plcErrorTable(){
        List<PlcErrorTableVo> list = new ArrayList<>();
        for (DevpSlave devp : slaveProperties.getDevp()) {
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            Map<Integer, StaProtocol> station = devpThread.getStation();

            for(Map.Entry<Integer, StaProtocol> entry : station.entrySet()) {
                StaProtocol staProtocol = entry.getValue();
//                if (staProtocol) {
//                    PlcErrorTableVo vo = new PlcErrorTableVo();
//                    vo.setNo(entry.getKey());   //  序号
//
//                    vo.setPlcDesc("");  //  todo:luxiaotao plc错误描述
//                    vo.setError("");    //  todo:luxiaotao 异常信息
//                    list.add(vo);
//                }
            }

        }

        list.sort((o1, o2) -> {
            if (o1.getNo().compareTo(o2.getNo()) > 0){
                return 1;
            }else if (o1.getNo().compareTo(o2.getNo()) < 0){
                return 0;
            }else{
                return -1;
            }

        });
        return R.ok().add(list);
    }

    @PostMapping("/output/site")
    @ManagerAuth(memo = "站点设备报文日志输出")
    public R siteOutput(){
        StringBuilder str = new StringBuilder();
        String s;
        int i = 0;
        while((s = OutputQueue.DEVP.poll()) != null && i <=10) {
            str.append("\n").append(s);
            i++;
        }
        return R.ok().add(str.toString());
    }

    /****************************************************************/
    /************************** 详情操作 ******************************/
    /****************************************************************/

    @GetMapping("/detl/{siteId}")
    public R siteDetl(@PathVariable("siteId") Integer siteId){
        SiteTableVo vo = new SiteTableVo();
        for (DevpSlave devp : slaveProperties.getDevp()) {
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            Map<Integer, StaProtocol> station = devpThread.getStation();
            for (Map.Entry<Integer, StaProtocol> entry : station.entrySet()) {
                if (siteId.equals(entry.getKey())) {
                    StaProtocol staProtocol = entry.getValue();
                    vo.setDevNo(entry.getKey());    // 站点编号
                    vo.setWorkNo(staProtocol.getWorkNo());   //  工作号
                    vo.setAutoing(staProtocol.isAutoing()?"Y":"N");     //  自动
                    vo.setLoading(staProtocol.isLoading()?"Y":"N");     // 有物
                    vo.setInEnable(staProtocol.isInEnable()?"Y":"N");   // 可入
                    vo.setOutEnable(staProtocol.isOutEnable()?"Y":"N"); // 可出
                    vo.setPakMk(staProtocol.isPakMk()?"Y":"N");       // 需求1
                    vo.setEmptyMk(staProtocol.isEmptyMk()?"Y":"N");     // 空板信号
                    vo.setStaNo(staProtocol.getStaNo());                // 目标站
                    return R.ok().add(vo);
                }
            }
        }
        return R.error("plc已掉线");
    }

    @PostMapping("/detl/update")
    @ManagerAuth(memo = "修改站点数据")
    public R siteDetlUpdate(@RequestParam Integer siteId,
                            @RequestParam Short workNo,
                            @RequestParam Short staNo,
                            @RequestParam String pakMk){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            Map<Integer, StaProtocol> station = devpThread.getStation();
            for (Map.Entry<Integer, StaProtocol> entry : station.entrySet()) {
                if (siteId.equals(entry.getKey())) {
                    StaProtocol staProtocol = entry.getValue();
                    staProtocol = staProtocol.clone();
                    if (workNo != null) {
                        staProtocol.setWorkNo(workNo);
                    }
                    if (staNo != null) {
                        staProtocol.setStaNo(staNo);
                    }
                    if (pakMk != null) {
                        staProtocol.setPakMk(pakMk.equals("Y"));
                    }
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (result) {
                        return R.ok();
                    } else {
                        return R.error("下发命令失败");
                    }
                }
            }
        }
        return R.error("plc已掉线");
    }


}

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

File was deleted

 src/main/java/com/zy/asrs/entity/WrkMast.java

@@ -3,6 +3,7 @@
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.FieldStrategy;
import com.baomidou.mybatisplus.enums.IdType;
import com.core.common.Cools;
import com.core.common.SpringUtils;
@@ -329,6 +330,13 @@
    @TableField("shuttle_no")
    private Integer shuttleNo;

    /**
     * 提升机号
     */
    @ApiModelProperty(value= "提升机号")
    @TableField(value = "lift_no",strategy = FieldStrategy.IGNORED)
    private Integer liftNo;

    public String getWrkSts$(){
        BasWrkStatusMapper mapper = SpringUtils.getBean(BasWrkStatusMapper.class);
        BasWrkStatus entity = mapper.selectById(this.wrkSts);

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

@@ -21,4 +21,6 @@
    BasDevp queryByLocNo(String locNo);

    BasDevp queryByQrCode(Integer qrCodeValue);

    List<BasDevp> selectLevSite();
}

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

@@ -101,12 +101,16 @@

    WrkMast selectByWorkNo(Integer workNo);

    WrkMast selectLiftStep262327();
    List<WrkMast> selectLiftStep262327();

    WrkMast selectByWorkNo372428(Integer workNo);

    List<WrkMast> selectBy2125();

    //查询指定楼层待分配车辆的任务
    List<LocMast> selectNoShuttleWrkByLev(String lev);
    List<WrkMast> selectNoShuttleWrkByLev(String lev);

    List<WrkMast> selectShuttleWrkByLev(String lev);

    WrkMast selectLiftWrkMast(Integer liftNo);
}

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

@@ -50,4 +50,7 @@

    BasDevp queryByQrCode(Integer qrCodeValue);

    //获取四层楼站点105,106,107,108
    List<BasDevp> selectLevSite();

}

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

@@ -15,6 +15,9 @@
    List<WrkMast> selectToBeHistoryData();

    //查询指定楼层待分配车辆的任务
    List<LocMast> selectNoShuttleWrkByLev(Integer lev);
    List<WrkMast> selectNoShuttleWrkByLev(Integer lev);

    //查询指定楼层已分配车辆的任务
    List<WrkMast> selectShuttleWrkByLev(Integer lev);

}

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

@@ -79,4 +79,9 @@
    public BasDevp queryByQrCode(Integer qrCodeValue) {
        return this.baseMapper.queryByQrCode(qrCodeValue);
    }

    @Override
    public List<BasDevp> selectLevSite() {
        return this.baseMapper.selectLevSite();
    }
}

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

@@ -673,15 +673,31 @@
                    if (wrkMast != null) {
                        if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 8) {
                            ShuttleThread shuttleThread = null;
                            ShuttleProtocol shuttleProtocol = null;
                            HashMap<String, Object> searchIdleShuttle = null;

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

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

@@ -719,14 +735,17 @@

                                Integer shuttleNo = wrkMast.getShuttleNo();//四向穿梭车号
                                shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
                                shuttleProtocol = shuttleThread.getShuttleProtocol();
                                if (!shuttleProtocol.isIdle(workNo)) {
                                    continue;
                                }
                            }

                            if (shuttleThread == null) {
                                continue;
                            }

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

@@ -751,55 +770,118 @@
                            //提升机口站点库位号
                            String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

                            if (wrkMast.getWrkSts() == 8 || Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
                                //同一层直接取货无需经过提升机
                            if (wrkMast.getWrkSts() == 4) {
                                if (currentLev == Utils.getLev(locNo)) {
                                    //小车和目标在同一楼层
                                    //直接计算车到提升机取货再到库位路径指令
                                    List<ShuttleCommand> commands = this.shuttleAssignCommand(wrkMast.getWrkSts() == 4 ? currentLocNo : liftSiteLocNo, liftSiteLocNo, locNo, assignCommand, shuttleThread);
                                    if (commands == null) {
                                        continue;//找不到路径等待下一次
                                    }
                                    assignCommand.setCommands(commands);
                                    //分配目标库位
                                    shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                    //目标库位
                                    assignCommand.setLocNo(wrkMast.getLocNo());
                                    wrkMast.setWrkSts(9L);//小车入库中
                                }else {
                                    //小车和目标不在同一楼层
                                    //小车移动到提升机口，计算路径
                                    List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                                    if (commands == null) {
                                        continue;//未找到路径
                                    }

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

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

                                    //分配目标库位
                                    shuttleProtocol.setLocNo(liftSiteLocNo);
                                    //目标库位
                                    assignCommand.setLocNo(liftSiteLocNo);
                                    assignCommand.setCommands(commands);
                                    wrkMast.setWrkSts(5L);//小车迁移状态
                                }
                            } else if (wrkMast.getWrkSts() == 8) {
                                //直接计算车到提升机取货再到库位路径指令
                                List<ShuttleCommand> commands = this.shuttleAssignCommand(wrkMast.getWrkSts() == 4 ? currentLocNo : liftSiteLocNo, liftSiteLocNo, locNo, assignCommand, shuttleThread);
                                if (commands == null) {
                                    continue;//找不到路径等待下一次
                                }
                                if (wrkMast.getWrkSts() == 8) {
                                    //此时车在提升机内部，下达一步指令让车移动到提升机口
                                    Integer staNo = Utils.levToOutInStaNo(currentLev >= 2 ? currentLev + 1 : currentLev);//站点号
                                    BasDevp basDevp = basDevpService.selectById(staNo);

                                    short startCode = liftProtocol.getBarcode();//提升机内部二维码
                                    Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
                                    Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
                                    //获取命令
                                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
                                    commands.add(0, moveCommand);//将该指令添加到队头
                                }
                                //此时车在提升机内部，下达一步指令让车移动到提升机口
                                Integer staNo = Utils.levToOutInStaNo(currentLev >= 2 ? currentLev + 1 : currentLev);//站点号
                                BasDevp basDevp = basDevpService.selectById(staNo);

                                short startCode = liftProtocol.getBarcode();//提升机内部二维码
                                Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
                                Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
                                //获取命令
                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
                                commands.add(0, moveCommand);//将该指令添加到队头

                                assignCommand.setCommands(commands);
                                //分配目标库位
                                shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                //目标库位
                                assignCommand.setLocNo(wrkMast.getLocNo());
                                wrkMast.setWrkSts(9L);//小车入库中
                            }else {
                                //不同层，将目标库位分配成提升机库位号

                                //小车移动到提升机口，计算路径
                                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                                if (commands == null) {
                                    continue;//未找到路径
                                }

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

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

                                //分配目标库位
                                shuttleProtocol.setLocNo(liftSiteLocNo);
                                //目标库位
                                assignCommand.setLocNo(liftSiteLocNo);
                                assignCommand.setCommands(commands);
                                wrkMast.setWrkSts(5L);//小车迁移状态
                            }

//                            if (wrkMast.getWrkSts() == 8 || Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
//                                //同一层直接取货无需经过提升机
//                                //直接计算车到提升机取货再到库位路径指令
//                                List<ShuttleCommand> commands = this.shuttleAssignCommand(wrkMast.getWrkSts() == 4 ? currentLocNo : liftSiteLocNo, liftSiteLocNo, locNo, assignCommand, shuttleThread);
//                                if (commands == null) {
//                                    continue;//找不到路径等待下一次
//                                }
//                                if (wrkMast.getWrkSts() == 8) {
//                                    //此时车在提升机内部，下达一步指令让车移动到提升机口
//                                    Integer staNo = Utils.levToOutInStaNo(currentLev >= 2 ? currentLev + 1 : currentLev);//站点号
//                                    BasDevp basDevp = basDevpService.selectById(staNo);
//
//                                    short startCode = liftProtocol.getBarcode();//提升机内部二维码
//                                    Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
//                                    Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
//                                    //获取命令
//                                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
//                                    commands.add(0, moveCommand);//将该指令添加到队头
//                                }
//                                assignCommand.setCommands(commands);
//                                //分配目标库位
//                                shuttleProtocol.setLocNo(wrkMast.getLocNo());
//                                //目标库位
//                                assignCommand.setLocNo(wrkMast.getLocNo());
//                                wrkMast.setWrkSts(9L);//小车入库中
//                            }else {
//                                //不同层，将目标库位分配成提升机库位号
//
//                                //小车移动到提升机口，计算路径
//                                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
//                                if (commands == null) {
//                                    continue;//未找到路径
//                                }
//
//                                //获取当前小车所在楼层的站点信息
//                                BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
//                                Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码
//
//                                //增加移动进提升机命令
//                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, endStartCode, 1400, 500);
//                                commands.add(moveCommand);
//
//                                //分配目标库位
//                                shuttleProtocol.setLocNo(liftSiteLocNo);
//                                //目标库位
//                                assignCommand.setLocNo(liftSiteLocNo);
//                                assignCommand.setCommands(commands);
//                                wrkMast.setWrkSts(5L);//小车迁移状态
//                            }

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
@@ -994,9 +1076,19 @@
                    LiftProtocol liftProtocol = liftThread.getLiftProtocol();

                    if (wrkMast.getWrkSts() == 21) {
                        //寻找最近且空闲的四向穿梭车
                        searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                        shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                        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，需要向小车下发命令从提升机移动出去，需要判断提升机状是否空闲、提升机是否到达目标楼层、目标楼层站点是否存在、目标楼层站点是否给出提升机到位信号

                        //判断提升机是否空闲
@@ -1051,17 +1143,16 @@
                        continue;
                    }

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

                    if (outStaLocNo == null) {
                        continue;
                    }

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

                        wrkMast.setShuttleNo(shuttleProtocol.getShuttleNo().intValue());//给工作档分配四向穿梭车号
                        if (!shuttleProtocol.isIdle()) {
                            continue;
                        }

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

@@ -1080,7 +1171,7 @@
                        assignCommand.setSourceLocNo(currentLocNo);

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

                            List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);
@@ -1140,6 +1231,9 @@
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 25) {
                        if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                            continue;
                        }

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

@@ -1212,6 +1306,18 @@
            distLocNo = locNo;
        }

        //判断当前任务所在楼层是否有其他任务已经分配了小车，如有则直接用该小车(一层楼仅分配一台车)
        List<WrkMast> wrkMasts = wrkMastService.selectShuttleWrkByLev(lev);//判断当前穿梭车楼层是否已有分配车辆的任务，如果有则分配这辆车
        if (wrkMasts.size() > 0) {
            //存在其他任务，分配这辆车
            WrkMast wrkMast1 = wrkMasts.get(0);
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast1.getShuttleNo());

            map.put("sameLay", true);//同层
            map.put("result", shuttleThread);
            return map;
        }

        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
@@ -1246,27 +1352,18 @@

        }

        Integer recentAllDistance = 9999999;
        if (sameLev.size() > 0) {
            //同一楼层有空闲穿梭车，则只在工作档楼层寻找
            //寻找离任务最近的穿梭车
            for (ShuttleThread shuttleThread : sameLev) {
                if (recentShuttle == null) {//最近穿梭车为空，则默认赋予为最近穿梭车
                    recentShuttle = shuttleThread;
                }

                //当前穿梭车库位号
                String currentLocNo = shuttleThread.getShuttleProtocol().getCurrentLocNo();
                //目前最近穿梭车库位号
                String recentLocNo = recentShuttle.getShuttleProtocol().getCurrentLocNo();

                //当前最近四向穿梭车到目标地点距离
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, distLocNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(recentShuttle.getSlave().getId(), Utils.getLev(recentLocNo)));//搜索空闲穿梭车，使用正常通道地图
                //当前穿梭车线程到目标地点距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, distLocNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), Utils.getLev(currentLocNo)));//搜索空闲穿梭车，使用正常通道地图
                if (recentShuttlePath == null || currentShuttlePath == null) {
                if (currentShuttlePath == null) {
                    continue;
                }
                Integer recentAllDistance = NavigateUtils.getOriginPathAllDistance(recentShuttlePath);//计算当前路径行走总距离
                Integer currentAllDistance = NavigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
                if (currentAllDistance < recentAllDistance) {
                    //如果当前楼层的车路径更小，则更新最近穿梭车
@@ -1284,29 +1381,18 @@
                //当前穿梭车库位号
                String currentLocNo = shuttleThread.getShuttleProtocol().getCurrentLocNo();
                int currentLev = Utils.getLev(currentLocNo);
                List<LocMast> locMasts = wrkMastService.selectNoShuttleWrkByLev(currentLev);//判断当前穿梭车楼层是否有待分配车辆的任务，如果有则不分配这辆车
                if (locMasts.size() > 0) {
                List<WrkMast> wrkMasts1 = wrkMastService.selectNoShuttleWrkByLev(currentLev);//判断当前穿梭车楼层是否有待分配车辆的任务，如果有则不分配这辆车
                if (wrkMasts1.size() > 0) {
                    //存在其他任务，跳过这辆车
                    continue;
                }

                if (recentShuttle == null) {//最近穿梭车为空，则默认赋予为最近穿梭车
                    recentShuttle = shuttleThread;
                }
                //目前最近穿梭车库位号
                String recentLocNo = recentShuttle.getShuttleProtocol().getCurrentLocNo();
                int recentLev = Utils.getLev(recentLocNo);


                //当前最近四向穿梭车到当前车子所在楼层的提升机口距离
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, Utils.levToOutInStaLocNo(recentLev), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), recentLev));//搜索空闲穿梭车，使用正常通道地图
                //当前穿梭车线程到当前车子所在楼层的提升机口距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, Utils.levToOutInStaLocNo(currentLev), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), currentLev));//搜索空闲穿梭车，使用正常通道地图
                if (recentShuttlePath == null || currentShuttlePath == null) {
                if (currentShuttlePath == null) {
                    continue;
                }

                Integer recentAllDistance = NavigateUtils.getOriginPathAllDistance(recentShuttlePath);//计算当前路径行走总距离
                Integer currentAllDistance = NavigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
                if (currentAllDistance < recentAllDistance) {
                    //如果当前楼层的车路径更小，则更新最近穿梭车
@@ -1349,6 +1435,8 @@
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 9://9.小车入库搬运中 ==> 14.入库完成
                            wrkMast.setWrkSts(14L);
                            //任务号清零
                            shuttleProtocol.setTaskNo((short) 0);
                            break;
                        case 5://5.迁移小车至提升机口 ==> 6.迁移小车至提升机口完成
                            wrkMast.setWrkSts(6L);
@@ -1367,6 +1455,8 @@
                            }

                            wrkMast.setWrkSts(27L);
                            //任务号清零
                            shuttleProtocol.setTaskNo((short) 0);
                            break;
                        default:
                    }
@@ -1374,8 +1464,6 @@
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        //设置四向穿梭车为空闲状态
                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                        //任务号清零
                        shuttleProtocol.setTaskNo((short) 0);
                        //源库位清零
                        shuttleProtocol.setSourceLocNo(null);
                        //目标库位清零
@@ -1386,9 +1474,14 @@

                        if (wrkMast.getWrkSts() == 27) {
                            if (moveAssignCommand != null) {
                                //下发任务
                                shuttleProtocol.setPakMk(true);
                                MessageQueue.offer(SlaveType.Shuttle, shuttleThread.getSlave().getId(), new Task(3, moveAssignCommand));
                                try {
                                    Thread.sleep(4000);
                                    //下发任务
                                    shuttleProtocol.setPakMk(true);
                                    MessageQueue.offer(SlaveType.Shuttle, shuttleThread.getSlave().getId(), new Task(3, moveAssignCommand));
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        }

@@ -1485,240 +1578,253 @@
            }

            //搜索是否有待处理的任务
            WrkMast wrkMast = wrkMastMapper.selectLiftStep262327();
            if (wrkMast == null) {
            List<WrkMast> wrkMasts = wrkMastMapper.selectLiftStep262327();
            if (wrkMasts.size() == 0) {
                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();
            }

            if (wrkMast.getWrkSts() == 2) {//2.设备上走
                if (liftProtocol.getTaskNo().intValue() != 0) {
                    //存在未完成任务号
                    continue;
                }
                if (liftProtocol.getPlatShuttleCheck()) {
                    //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
            for (WrkMast wrkMast : wrkMasts) {
                //搜索是否有其他任务占用了提升机，如果占用提升机的任务和当前任务相同，则运行执行
                WrkMast wrkMast1 = wrkMastMapper.selectLiftWrkMast(liftProtocol.getLiftNo().intValue());
                if (wrkMast1 != null && wrkMast1.getWrkNo().intValue() != wrkMast.getWrkNo().intValue()) {
                    continue;
                }

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

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getLocNo();
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                if (wrkMast.getWrkSts() == 2) {//2.设备上走
                    if (liftProtocol.getTaskNo().intValue() != 0) {
                        //存在未完成任务号
                        continue;
                    }
                    if (liftProtocol.getPlatShuttleCheck()) {
                        //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
                        continue;
                    }

                Integer levTmp = wrkMastLocNoLey;
                if (wrkMastLocNoLey >= 2) {
                    levTmp += 1;
                }
                Integer distStaNo = Utils.levToOutInStaNo(levTmp);
                    //获取目标站
                    StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getStaNo());
                    if (staProtocol.isLoading() || !staProtocol.isInEnable()) {//目标站有物，不可入，禁止分配任务
                        continue;
                    }

                if (liftProtocol.getPositionArrivalFeedback().intValue() != LiftLevType.TWO.realLev.intValue()) {
                    //提升机不在输送线楼层，获取到输送线层的提升机命令
                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                    commands.add(command1);//将命令添加进list
                }
                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                //输送线将货物运进来(无货正转)
                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
                    Integer levTmp = wrkMastLocNoLey;
                    if (wrkMastLocNoLey >= 2) {
                        levTmp += 1;
                    }
                    Integer distStaNo = Utils.levToOutInStaNo(levTmp);

                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), levTmp);
                commands.add(command3);//将命令添加进list
                    if (liftProtocol.getPositionArrivalFeedback().intValue() != LiftLevType.TWO.realLev.intValue()) {
                        //提升机不在输送线楼层，获取到输送线层的提升机命令
                        LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                        commands.add(command1);//将命令添加进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
                    //输送线将货物运进来(无货正转)
                    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

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中
                    //提升机前往目标楼层(工作档目标楼层)
                    LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), levTmp);
                    commands.add(command3);//将命令添加进list

                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());//设置四向穿梭车号
                    //提升机到达指定楼层，输送线将货物移出去(正转)
                    //输送线将货物移出去
                    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

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

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getLocNo();
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                if (wrkMastLocNoLey >= 2) {
                    wrkMastLocNoLey++;
                }
                    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());//设置四向穿梭车号

                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                commands.add(command1);//将命令添加进list
                    //判断小车是否在提升机内，且处于空闲状态
                    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;
                    }

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中
                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                    if (wrkMastLocNoLey >= 2) {
                        wrkMastLocNoLey++;
                    }

                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()) {
                    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.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

                    //给提升机分配任务
                    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);
                    commands.add(command3);//将命令添加进list

                    //提升机到达指定楼层，输送线将货物移出去(反转)
                    //输送线将货物移出去
                    LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 2);
                    command4.setOperaStaNo((short) 102);//操作102站
                    command4.setRotationDire(2);//给输送线下发链条转动信号，反转
                    command4.setDevpId(devpId);
                    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.提升机搬运中
                }

                //输送线将货物运进来(无货反转)
                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);
                commands.add(command3);//将命令添加进list

                //提升机到达指定楼层，输送线将货物移出去(反转)
                //输送线将货物移出去
                LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 2);
                command4.setOperaStaNo((short) 102);//操作102站
                command4.setRotationDire(2);//给输送线下发链条转动信号，反转
                command4.setDevpId(devpId);
                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.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));
                }
            }

            //所需命令组合完毕，更新数据库，提交到线程去工作
            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));
            }
        }
    }

@@ -1774,6 +1880,7 @@
                            wrkMast.setWrkSts(4L);
                            //任务号清零
                            liftProtocol.setTaskNo((short) 0);
                            wrkMast.setLiftNo(null);//提升机解锁
                            break;
                        case 7://7.提升机迁移小车中 ==> 8.提升机迁移小车完成
                            if (liftProtocol.getLev().intValue() != lev) {
@@ -1795,6 +1902,7 @@
                            wrkMast.setWrkSts(34L);//34.出库完成，暂时先直接完成出库工作档，后续需要根据输送线给出的状态来确定34.出库完成状态
                            //任务号清零
                            liftProtocol.setTaskNo((short) 0);
                            wrkMast.setLiftNo(null);//提升机解锁
                            break;
                        default:
                    }
@@ -2697,7 +2805,7 @@
                //小车已经达到提升机内

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

@@ -2788,6 +2896,9 @@
            }else if (wrkCharge.getWrkSts() == 57) {//57.小车到达充电桩
                //充电中
                //判断小车是否充满电量，满电1000或电压54V以上
                if (shuttleProtocol.getBatteryPower() == null || shuttleProtocol.getCurrentVoltage() == null) {
                    continue;
                }
                if (shuttleProtocol.getBatteryPower() >= 1000 && shuttleProtocol.getCurrentVoltage() >= 54000) {
                    //充满，断开充电
//                    List<ShuttleCommand> commands = new ArrayList<>();

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

@@ -29,7 +29,12 @@
    }

    @Override
    public List<LocMast> selectNoShuttleWrkByLev(Integer lev) {
    public List<WrkMast> selectNoShuttleWrkByLev(Integer lev) {
        return this.baseMapper.selectNoShuttleWrkByLev("%" + lev);
    }

    @Override
    public List<WrkMast> selectShuttleWrkByLev(Integer lev) {
        return this.baseMapper.selectShuttleWrkByLev("%" + lev);
    }
}

 src/main/java/com/zy/asrs/utils/Utils.java

@@ -445,7 +445,7 @@

    //检测穿梭车行走路径，是否存在其他小车，如有其他小车则进行调离
    public static boolean checkShuttlePath(List<NavigateNode> nodes, Integer shuttleId) {
          boolean flag = false;
        boolean flag = false;
        int shuttleX = -1;
        int shuttleY = -1;
        int shuttleZ = -1;
@@ -506,6 +506,11 @@
                return false;
            }

            ShuttleProtocol shuttleProtocol = currentShuttleThread.getShuttleProtocol();
            if (!shuttleProtocol.isIdle()) {
                return false;//被调度的小车处于工作状态，禁止触发避让任务
            }

            //搜索一条没有小车的空巷道，并调度小车
            ShuttleAssignCommand assignCommand = Utils.searchEmptyGroupToMoveShuttle(shuttleZ, shuttleId, currentShuttleThread, null);//shuttleId搜索时需要排除的车辆id，currentShuttleThread是需要被调度的车辆线程


 src/main/java/com/zy/core/model/protocol/LiftProtocol.java

@@ -246,6 +246,29 @@
    }

    // 是否处于空闲待命状态
    public Boolean isIdle(Short taskNo) {
        if(this.taskNo == null
                || this.liftLock == null
                || this.ready == null
                || this.running == null
                || this.mode == null
                || this.pakMk == null
        ){
            return false;
        }

        boolean res = (this.taskNo == 0 || this.taskNo.intValue() == taskNo.intValue())
                && !this.liftLock
//                && this.ready
                && !this.running
                && this.mode
                && this.pakMk.equals(true)
                && !this.securityMk
                ;
        return res;
    }

    // 是否处于空闲待命状态
    public Boolean isIdle() {
        if(this.taskNo == null
                || this.liftLock == null

 src/main/java/com/zy/core/model/protocol/ShuttleProtocol.java

@@ -264,7 +264,8 @@
        boolean res = this.busyStatusType.equals(ShuttleStatusType.IDLE)
                && this.pakMk.equals(true)
                && this.errorCodeType.equals(ShuttleErrorCodeType.NORMAL)
                && (this.taskNo == 0 || this.taskNo == taskNo)
                && (this.taskNo == 0 || this.taskNo.intValue() == taskNo.intValue())
                && this.protocolStatus.intValue() == ShuttleProtocolStatusType.IDLE.id
                ;
        if (!res) {
            return res;

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

@@ -646,88 +646,21 @@
            return false;
        }

        WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);

        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
        if (o == null) {
            return false;
        }
        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);

        if (shuttleProtocol.getBusyStatus().intValue() == ShuttleStatusType.BUSY.id) {
            return false;//小车状态忙
        }

        if (!checkLiftStation(wrkNo)) {//检测是否有提升机站点，有则调度提升机
            return false;
        }

//        List<ShuttleCommand> errorCommands = redisCommand.getErrorCommands();
//        if (errorCommands.size() > 0) {
//            //优先执行该指令
//            ShuttleCommand errorCommand = errorCommands.get(0);//取出指令
//
//            if(errorCommand.getCommandWord() == 1){//正常行走命令，需要先执行完找库位命令后，再执行
//                LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
//                LocMast locMast = locMastService.queryByQrCode(shuttleProtocol.getCurrentCode().toString());
//                LocMast distLocMast = locMastService.queryByQrCode(errorCommand.getStartCodeNum().toString());
//                if (shuttleProtocol.getCurrentCode().equals(errorCommand.getStartCodeNum())) {
//                    //起点和终点属于同一库位，无需再执行移动操作
//                    errorCommands.remove(0);//移除该命令
//                    redisCommand.setErrorCommands(new ArrayList<ShuttleCommand>());
//                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WORKING);
//                    //当前步序
//                    int commandStep = redisCommand.getCommandStep();
//                    //步序回退
//                    commandStep--;
//                    redisCommand.setCommandStep(commandStep);
//                    //任务数据保存到redis
//                    redisUtil.set("shuttle_wrk_no_" + wrkNo, JSON.toJSONString(redisCommand));
//                    shuttleProtocol.setPakMk(true);
//                    return true;
//                }else {
//                    List<NavigateNode> result = NavigateUtils.calc(locMast.getLocNo(), distLocMast.getLocNo(), NavigationMapType.DFX.id, Utils.getShuttlePoints(errorCommand.getShuttleNo().intValue()));//错误恢复，使用DFX地图
//                    if (result != null) {
//                        //获取分段路径
//                        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(result);
//                        //将每一段路径分成command指令
//                        for (ArrayList<NavigateNode> nodes : data) {
//                            //开始路径
//                            NavigateNode startPath = nodes.get(0);
//                            //目标路径
//                            NavigateNode endPath = nodes.get(nodes.size() - 1);
//                            Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
//
//                            String qrCodeValue = distLocMast.getQrCodeValue();
//                            errorCommand.setCommandWord((short) 1);
//                            errorCommand.setStartCodeNum(shuttleProtocol.getCurrentCode());
//                            errorCommand.setMiddleCodeNum((short) 1);
//                            errorCommand.setDistCodeNum((short) Integer.parseInt(qrCodeValue));
//                            errorCommand.setStartToDistDistance(allDistance);
//                            errorCommand.setRunSpeed((short) 1000);
//                            errorCommand.setRunDirection(ShuttleRunDirection.get(startPath.getDirection()).id);
//                            errorCommand.setForceMoveDistance(0);
//                            errorCommand.setIOControl((short) 0);
//                            errorCommand.setCommandEnd((short) 1);
//                            break;
//                        }
//                    }
//                }
//
//                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WORKING);
//                //当前步序
//                int commandStep = redisCommand.getCommandStep();
//                //步序回退
//                commandStep--;
//                redisCommand.setCommandStep(commandStep);
//            }
//
//            if (!write(errorCommand)) {
//                News.error("四向穿梭车命令下发失败，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(errorCommand));
//                return false;
//            } else {
//                News.info("四向穿梭车命令下发成功，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(errorCommand));
//                errorCommands.remove(0);
//                redisCommand.setErrorCommands(errorCommands);
//                //任务数据保存到redis
//                redisUtil.set("shuttle_wrk_no_" + wrkNo, JSON.toJSONString(redisCommand));
//                return true;
//            }
//        }

        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
        LiftProtocol liftProtocol = liftThread.getLiftProtocol();
@@ -751,10 +684,36 @@
                    //上一条指令起点是提升机二维码，则清零提升机任务号
                    if (command.getStartCodeNum().intValue() == liftProtocol.getBarcode().intValue()) {
                        //判断提升机是否处于空闲
                        if (liftProtocol.isIdleNoTask()) {
                        if (liftProtocol.isIdleNoTask() && liftProtocol.getTaskNo().intValue() == redisCommand.getWrkNo().intValue()) {
                            liftProtocol.setTaskNo((short) 0);//清空任务号
                            WrkMast wrkMast = wrkMastService.selectById(wrkNo);
                            if (wrkMast != null) {
                                wrkMast.setLiftNo(null);//解锁提升机
                                wrkMastService.updateById(wrkMast);
                            }
                        }
                    }

                    //入库命令，当小车取完货后，需要将提升机释放
                    if (assignCommand.getTaskMode().intValue() == ShuttleTaskModeType.PAK_IN.id) {
                        //判断上一条指令的起点是否为输送站点且目标点不是提升机内部二维码
                        Short startCodeNum = command.getStartCodeNum();
                        BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
                        BasDevp basDevp = basDevpService.queryByQrCode(startCodeNum.intValue());//目标站点
                        if (basDevp != null && command.getDistCodeNum().intValue() != liftProtocol.getBarcode().intValue()) {
                            //上一条指令的起点为输送站点且目标点不是提升机内部二维码
                            //此时小车应该已经离开输送站点，判断提升机是否空闲且有工作号
                            if (liftProtocol.isIdleNoTask() && liftProtocol.getTaskNo().intValue() == redisCommand.getWrkNo().intValue()) {
                                liftProtocol.setTaskNo((short) 0);//清空任务号
                                WrkMast wrkMast = wrkMastService.selectById(wrkNo);
                                if (wrkMast != null) {
                                    wrkMast.setLiftNo(null);//解锁提升机
                                    wrkMastService.updateById(wrkMast);
                                }
                            }
                        }
                    }

                }
            } else if (command.getCommandWord().intValue() == 2) {
                //托盘顶升命令
@@ -981,11 +940,10 @@
            if (commands.get(0).getStartCodeNum() == null) {
                return false;
            }
            //命令起始位置就是提升机二维码，则不进行校验
            if (commands.get(0).getStartCodeNum().intValue() == liftProtocol.getBarcode().intValue()) {
                return true;
            }
        }

        //当前等待执行的指令
        ShuttleCommand command = commands.get(commandStep);

        BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
        ArrayList<Short> qrCodeValues = new ArrayList<>();
@@ -994,32 +952,53 @@
            qrCodeValues.add(Short.parseShort(basDevp.getQrCodeValue()));
        }

        //遍历所有指令，判断是否有到提升机口的指令或从提升机口前往提升机内的指令，并获取到达该提升机口所需步序
        int step = 0;
        Integer siteNo = null;//站点号
        ShuttleCommand command = null;
        for (int i = 0; i < commands.size(); i++) {
            command = commands.get(i);
            for (Short qrCodeValue : qrCodeValues) {
                //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
                if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
                    continue;
                }
        for (Short qrCodeValue : qrCodeValues) {
            //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
            if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
                continue;
            }

                if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
                    //存在
                    step = i + 1;
                    BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
                    siteNo = basDevp.getDevNo();
                    break;
                }
            if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
                //存在
                BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
                siteNo = basDevp.getDevNo();
                break;
            }
        }

        if (step == 0) {
            //无需后续检测，直接放行
        if (siteNo == null) {
            //找不到站点，说明还未到提升机
            return true;
        }


//        //遍历所有指令，判断是否有到提升机口的指令或从提升机口前往提升机内的指令，并获取到达该提升机口所需步序
//        int step = 0;
//        Integer siteNo = null;//站点号
//        ShuttleCommand command = null;
//        for (int i = 0; i < commands.size(); i++) {
//            command = commands.get(i);
//            for (Short qrCodeValue : qrCodeValues) {
//                //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
//                if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
//                    continue;
//                }
//
//                if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
//                    //存在
//                    step = i + 1;
//                    BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
//                    siteNo = basDevp.getDevNo();
//                    break;
//                }
//            }
//        }
//
//        if (step == 0) {
//            //无需后续检测，直接放行
//            return true;
//        }

        //判断下一步是否为提升机口或提升机内
        if (commandStep < commands.size()) {
@@ -1032,10 +1011,6 @@
                }
            }
        }
//        if (commandStep + 1 != step) {
//            //下一步不是提升机口，跳过后续流程
//            return true;
//        }

        //获取四向穿梭车当前楼层
        String shuttleLocNo = shuttleProtocol.getCurrentLocNo();//二维码对应库位号
@@ -1047,29 +1022,39 @@
        }

        //判断输送线站点是否给出提升机到位信号
        if (siteNo != null) {
            SiemensDevpThread siemensDevpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocol = siemensDevpThread.getStation().get(siteNo);
            if (!staProtocol.isLiftArrival()) {
                //输送线反馈提升机没有到位
                executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
                return false;
            }

            if (shuttleProtocol.getCurrentCode().intValue() == liftProtocol.getBarcode().intValue()) {
                //小车处于提升机内
                return true;
            }else {
                if (liftProtocol.getPositionArrivalFeedback$() == shuttleLocNoLev) {
                    liftProtocol.setTaskNo(wrkNo);//给提升机写工作号，防止被占用
                    return true;//提升机到位
                }
                executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
                return false;//提升机没有到位
            }
        SiemensDevpThread siemensDevpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        StaProtocol staProtocol = siemensDevpThread.getStation().get(siteNo);
        if (!staProtocol.isLiftArrival()) {
            //输送线反馈提升机没有到位
            executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
            return false;
        }

        return false;
        if (shuttleProtocol.getCurrentCode().intValue() == liftProtocol.getBarcode().intValue()) {
            //小车处于提升机内
            return true;
        }else {
            if (liftProtocol.getPositionArrivalFeedback$() == shuttleLocNoLev) {
                //判断提升机是否有任务号
                if (liftProtocol.getTaskNo().intValue() != 0) {
                    //判断任务号是否和当前小车任务一致
                    if (liftProtocol.getTaskNo().intValue() != wrkNo.intValue()) {
                        return false;//任务号不一致，且提升机任务号不为0
                    }
                }
                liftProtocol.setTaskNo(wrkNo);//给提升机写工作号，防止被占用
                WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);
                WrkMast wrkMast = wrkMastService.selectById(shuttleProtocol.getTaskNo());
                if (wrkMast != null) {
                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//锁定提升机，防止被抢占
                    wrkMastService.updateById(wrkMast);
                }
                return true;//提升机到位
            }
            executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
            return false;//提升机没有到位
        }

    }

    private boolean executeLift(LiftThread liftThread, LiftProtocol liftProtocol, ShuttleRedisCommand redisCommand, Integer shuttleLocNoLev) {//调度提升机
@@ -1088,6 +1073,13 @@
            return false;
        }

        WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);
        WrkMast wrkMast = wrkMastService.selectById(shuttleProtocol.getTaskNo());
        if (wrkMast != null) {
            wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//锁定提升机，防止被抢占
            wrkMastService.updateById(wrkMast);
        }

        //给提升机分配任务
        liftProtocol.setTaskNo(shuttleProtocol.getTaskNo());//设置任务号
        liftProtocol.setShuttleNo(shuttleProtocol.getShuttleNo());//设置四向穿梭车号

 src/main/resources/mapper/BasDevpMapper.xml

@@ -88,4 +88,11 @@
        where 1=1
        and qr_code_value = #{qrCodeValue}
    </select>

    <select id="selectLevSite" resultMap="BaseResultMap">
        select *
        from asr_bas_devp
        where 1=1
        and dev_no in ('105','106','107','108')
    </select>
</mapper>

 src/main/resources/mapper/WrkMastMapper.xml

@@ -62,6 +62,7 @@
        <result column="ctn_no" property="ctnNo" />
        <result column="full_plt" property="fullPlt" />
        <result column="shuttle_no" property="shuttleNo" />
        <result column="lift_no" property="liftNo" />

    </resultMap>

@@ -240,7 +241,7 @@
        select top 1 *
        from dbo.asr_wrk_mast
        where 1=1
        and ((wrk_sts = 4 and shuttle_no is null) or (wrk_sts = 8 and shuttle_no is not null))
        and ((wrk_sts = 4) or (wrk_sts = 8 and shuttle_no is not null))
        and sta_no = #{staNo}
        and wrk_no=#{workNo}
        order by io_pri desc,wrk_sts desc
@@ -252,7 +253,7 @@
    </select>

    <select id="selectLiftStep262327" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast
        select * from dbo.asr_wrk_mast
        where 1=1
        and (wrk_sts in (6,23,27)
            and shuttle_no is not null)
@@ -276,7 +277,19 @@
    <select id="selectNoShuttleWrkByLev" resultMap="BaseResultMap">
        select * from dbo.asr_wrk_mast
        where shuttle_no is null
        and (wrk_sts = 2 and loc_no like #{lev}) or (wrk_sts = 21 and source_loc_no like #{lev})
        and ((wrk_sts = 2 and loc_no like #{lev}) or (wrk_sts = 21 and source_loc_no like #{lev}))
        order by io_pri desc,wrk_sts desc
    </select>

    <select id="selectShuttleWrkByLev" resultMap="BaseResultMap">
        select * from dbo.asr_wrk_mast
        where shuttle_no is not null
        and ((wrk_sts not in (14,15)  and loc_no like #{lev}) or (wrk_sts not in (34,35) and source_loc_no like #{lev}))
        order by io_pri desc,wrk_sts desc
    </select>

    <select id="selectLiftWrkMast" resultMap="BaseResultMap">
        select top 1 * from asr_wrk_mast
        where lift_no = #{liftNo}
    </select>
</mapper>