#

Junjie

2025-01-08 97821c4acc241cd65fd4ae890a44201df065c590

#

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

@@ -53,4 +53,6 @@

    WrkMast selectChargeWorking(Integer shuttleNo);

    WrkMast selectChargeWorkingByChargeSta(Integer chargeSta);

}

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

@@ -22,6 +22,8 @@

    WrkMast selectChargeWorking(Integer shuttleNo);

    WrkMast selectChargeWorkingByChargeSta(Integer chargeSta);

    Boolean hasBusyByShuttle(Integer shuttleNo);

    WrkMast selectShuttleHasMoveWorking(Integer shuttleNo);

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

@@ -1835,58 +1835,59 @@

                //小车所在楼层
                int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
//                ShuttleChargeType shuttleCharge = null;
//
//                //搜索小车所在楼层有没有充电桩
//                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
//                    if (lev != Utils.getLev(chargeType.locNo)) {
//                        continue;//小车和充电桩不在同一层
//                    }
//
//                    //小车和充电桩在同一层
//                    if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
//                        shuttleCharge = chargeType;
//                        break;
//                    }
//                }
//
//                if (shuttleCharge == null) {
//                    //同楼层没有找到充电桩，找可用充电桩
//                    //小车同楼层没有充电桩，只要充电桩可用就生成充电任务
//                    for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
//                        if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
//                            //判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
//                            int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
//                            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
//                            if (checkLevHasShuttle) {
//                                //当前充电桩楼层有穿梭车，不分配该充电桩
//                                continue;
//                            }
//
//                            shuttleCharge = chargeType;
//                            break;
//                        }
//                    }
//                }
//
//                if (shuttleCharge == null) {
//                    continue;
//                }
//
//                String chargeLocNo = shuttleCharge.locNo;
//                wrkCharge = new WrkCharge();
//                wrkCharge.setShuttleNo(shuttle.getId());
//                wrkCharge.setCharge(shuttleCharge.id);
//                wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
//                wrkCharge.setWrkSts(51L);   // 51.准备充电
//                wrkCharge.setIoPri((double) 10);
//                wrkCharge.setLocNo(chargeLocNo);
//                wrkCharge.setMemo("charge");
//                wrkCharge.setAppeTime(new Date());
//                if (!wrkChargeService.insert(wrkCharge)) {
//                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
//                    continue;
//                }
                ShuttleChargeType shuttleCharge = null;

                //搜索小车所在楼层有没有充电桩
                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                    if (lev != Utils.getLev(chargeType.locNo)) {
                        continue;//小车和充电桩不在同一层
                    }

                    //小车和充电桩在同一层
                    if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
                        shuttleCharge = chargeType;
                        break;
                    }
                }

                if (shuttleCharge == null) {
                    //同楼层没有找到充电桩，找可用充电桩
                    //小车同楼层没有充电桩，只要充电桩可用就生成充电任务
                    for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                        if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
                            //判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
                            int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
                            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
                            if (checkLevHasShuttle) {
                                //当前充电桩楼层有穿梭车，不分配该充电桩
                                continue;
                            }

                            shuttleCharge = chargeType;
                            break;
                        }
                    }
                }

                if (shuttleCharge == null) {
                    continue;
                }

                String chargeLocNo = shuttleCharge.locNo;
                wrkMast = new WrkMast();
                wrkMast.setMk(String.valueOf(shuttleCharge.id));
                wrkMast.setWrkNo(commonService.getWorkNo(WrkIoType.SHUTTLE_CHARGE.id));
                wrkMast.setWrkSts(WrkStsType.NEW_CHARGE.sts);
                wrkMast.setIoType(WrkIoType.SHUTTLE_CHARGE.id);//300.充电
                wrkMast.setIoPri((double) 999);
                wrkMast.setLocNo(chargeLocNo);
                wrkMast.setShuttleNo(shuttle.getId());
                wrkMast.setMemo("charge");
                wrkMast.setAppeTime(new Date());
                if (!wrkMastService.insert(wrkMast)) {
                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                    continue;
                }

                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
            }
@@ -1895,135 +1896,224 @@
        }
    }

//    /**
//     * 执行四向穿梭车充电任务
//     */
//    public synchronized void executeShuttleCharge() {
//        try {
//            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
//                WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttle.getId());
//                if (wrkCharge == null) {
//                    continue;
//                }
//
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
//                if (shuttleThread == null) {
//                    continue;
//                }
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                if (wrkCharge.getWrkSts() == 51) {
//                    if (!shuttleProtocol.isIdleNoCharge()) {
//                        continue;
//                    }
//
//                    if (shuttleProtocol.getSuspendState() == 1) {
//                        continue;//管制中
//                    }
//
//                    if (!shuttleProtocol.getCurrentLocNo().equals(wrkCharge.getLocNo())) {
//                        //小车不在充电桩位置
//                        shuttleDispatchUtils.dispatchShuttle(wrkCharge.getWrkNo(), wrkCharge.getLocNo(), shuttle.getId());//调度小车去充电桩
//                        continue;
//                    }
//
//                    //小车已经在充电桩位置，下发充电命令
//                    NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), true);
//                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
//                    commands.add(chargeCommand);
//                    //创建分配命令
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
//                    assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
//                    assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//                    assignCommand.setCommands(commands);//运行命令
//
//                    wrkCharge.setWrkSts(52L);//51.生成充电任务 => 52.小车去充电中
//                    wrkCharge.setModiTime(new Date());
//                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//                        //下发任务
//                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//                    }
//                } else if (wrkCharge.getWrkSts() == 52) {
//                    //检测小车是否满电
//
//                    //获取满电阈值
//                    int maxPower = 95;
//                    EntityWrapper<Config> wrapper = new EntityWrapper<>();
//                    wrapper.eq("code", "chargeMaxValue");
//                    Config config = configService.selectOne(wrapper);
//                    if (config != null) {
//                        maxPower = Integer.parseInt(config.getValue());
//                    }
//
//                    if (shuttleProtocol.getPowerPercent() < maxPower) {
//                        continue;
//                    }
//
//                    //***************判断是否满充校准***************
//                    EntityWrapper<Config> wrapper1 = new EntityWrapper<>();
//                    wrapper.eq("code", "shuttleMaxPowerVerify");
//                    Config config1 = configService.selectOne(wrapper1);
//                    if (config1 != null) {
//                        if (config1.getValue().equals("true")) {
//                            if (shuttleProtocol.getVoltage() < 5630) {
//                                continue;//电压不够继续充电
//                            }
//                        }
//                    }
//                    //***************判断是否满充校准***************
//
//                    //小车满电，结束充电任务
//                    NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), false);
//                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
//                    commands.add(chargeCommand);
//                    //创建分配命令
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
//                    assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
//                    assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//                    assignCommand.setCommands(commands);//运行命令
//
//                    //下发任务
//                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//                    try {
//                        Thread.sleep(3000);
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//
//                    wrkCharge.setWrkSts(53L);//52.小车去充电中 => 53.小车充电完成
//                    wrkCharge.setModiTime(new Date());
//                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE.id);
//                        shuttleProtocol.setTaskNo(0);
//                        shuttleProtocol.setPakMk(false);
//                    }
//                } else if (wrkCharge.getWrkSts() == 53) {
//                    if (shuttleProtocol.getChargState() == 0) {//小车处于未充电状态
//                        boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkCharge.getLocNo()), shuttleThread.getSlave().getId(), shuttleThread);
//                        if (!result) {
//                            continue;
//                        }
//
//                        wrkCharge.setWrkSts(60L);//53.小车充电完成 => 60.充电任务完成
//                        wrkCharge.setModiTime(new Date());
//                        if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//
//                        }
//                    }
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    /**
     * 执行四向穿梭车充电任务
     */
    public synchronized void executeShuttleCharge() {
        try {
            //查询小车移库任务
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttle.getId());
                if(wrkMast == null) {
                    continue;
                }

                boolean result1 = this.executeShuttleChargeStepGoToChargeSta(wrkMast);//小车等待充电桩
                if (!result1) {
                    continue;
                }

                boolean result2 = this.executeShuttleChargeStepArrivalChargeSta(wrkMast);//小车到达充电桩
                if (!result2) {
                    continue;
                }

                boolean result3 = this.executeShuttleChargeStepStartCharge(wrkMast);//小车开始充电
                if (!result3) {
                    continue;
                }

                boolean result4 = this.executeShuttleChargeStepStopCharge(wrkMast);//小车停止充电
                if (!result4) {
                    continue;
                }

                boolean result5 = this.executeShuttleChargeStepLeaveCharge(wrkMast);//小车离开充电桩
                if (!result5) {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 小车前往充电桩
     */
    private synchronized boolean executeShuttleChargeStepGoToChargeSta(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.NEW_CHARGE.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
                //小车在充电桩位置
                wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);
                wrkMast.setModiTime(new Date());
                wrkMastService.updateById(wrkMast);
                return false;
            }

            //调度小车去充电桩
            boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getLocNo(), wrkMast.getShuttleNo());
            if (!dispatched) {
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN.sts);//小车前往充电桩
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);
            return false;
        }
        return true;
    }

    /**
     * 小车到达充电桩
     */
    private synchronized boolean executeShuttleChargeStepArrivalChargeSta(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //判断是否存在未完成的移动任务
            WrkMast moveWrk = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if(moveWrk != null) {
                return false;
            }

            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
                return false;
            }

            //小车在充电桩位置
            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);//小车到达充电桩
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);

            return false;
        }
        return true;
    }

    //小车开始充电
    private synchronized boolean executeShuttleChargeStepStartCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车已经在充电桩位置，下发充电命令
            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

            List<ShuttleCommand> commands = shuttleOperaUtils.shuttleChargeCommand(assignCommand, shuttleThread, true);
            assignCommand.setCommands(commands);//运行命令

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_WORKING.sts);
            wrkMast.setModiTime(new Date());
            if (!wrkMastService.updateById(wrkMast)) {
                return false;
            }

            //下发任务
            shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            return false;
        }
        return true;
    }

    //小车停止充电
    private synchronized boolean executeShuttleChargeStepStopCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            if (!shuttleThread.isChargingCompleted()) {
                return false;
            }

            //小车已经在充电桩位置，下发停止充电命令
            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

            List<ShuttleCommand> commands = shuttleOperaUtils.shuttleChargeCommand(assignCommand, shuttleThread, false);
            assignCommand.setCommands(commands);//运行命令

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
            wrkMast.setModiTime(new Date());
            if (!wrkMastService.updateById(wrkMast)) {
                return false;
            }

            //下发任务
            shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            return false;
        }
        return true;
    }

    //小车离开充电桩
    private synchronized boolean executeShuttleChargeStepLeaveCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            ShuttleChargeType chargeType = ShuttleChargeType.get(wrkMast.getMk());
            if(chargeType == null) {
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
            wrkMast.setModiTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                //调度小车去待机位
                boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), chargeType.waitLocNo, wrkMast.getShuttleNo());
                if (!dispatched) {
                    return false;
                }
                return false;
            }

            return false;
        }
        return true;
    }

    /**
     * 执行小车移库任务

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

@@ -64,6 +64,11 @@
    }

    @Override
    public WrkMast selectChargeWorkingByChargeSta(Integer chargeSta) {
        return this.baseMapper.selectChargeWorkingByChargeSta(chargeSta);
    }

    @Override
    public Boolean hasBusyByShuttle(Integer shuttleNo) {
        List<WrkMast> wrkMasts = this.selectList(new EntityWrapper<WrkMast>().in("wrk_sts"
                , WrkStsType.NEW_INBOUND.sts

 src/main/java/com/zy/common/model/NavigateNode.java

@@ -32,7 +32,7 @@
        this.Father = father;
        if (this.Father != null) {
            //走过的步数等于父节点走过的步数加一
            this.G = father.G + 1;
            this.G = father.G + this.G;
        } else { //父节点为空代表它是第一个结点
            this.G = 0;
        }

 src/main/java/com/zy/common/model/enums/WrkChargeType.java

File was deleted

 src/main/java/com/zy/common/utils/NavigateSolution.java

@@ -13,9 +13,7 @@
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.*;

/**
 * 四向库核心
@@ -45,10 +43,10 @@
    public PriorityQueue<NavigateNode> Open = new PriorityQueue<NavigateNode>();
    //Close表用普通的数组
    public ArrayList<NavigateNode> Close = new ArrayList<NavigateNode>();
    //Exist表用来存放已经出现过的结点。
    public ArrayList<NavigateNode> Exist = new ArrayList<NavigateNode>();
    //用来存放已经出现过的结点。
    Map<String, Integer> bestGMap = new HashMap<>();

    public String astarSearch(NavigateNode start, NavigateNode end, String pythonScriptPath) {
    public String astarSearchPython(NavigateNode start, NavigateNode end, String pythonScriptPath) {
        String maps = JSON.toJSONString(map);
        String startStr = start.getX() + "-" + start.getY();
        String targetStr = end.getX() + "-" + end.getY();
@@ -104,44 +102,45 @@
        return null;
    }

//    public NavigateNode astarSearch(NavigateNode start, NavigateNode end) {
//        //把第一个开始的结点加入到Open表中
//        this.Open.add(start);
//        //把出现过的结点加入到Exist表中
//        this.Exist.add(start);
//        //主循环
//        while (Open.size() > 0) {
//            //取优先队列顶部元素并且把这个元素从Open表中删除
//            NavigateNode current_node = Open.poll();
//            //将这个结点加入到Close表中
//            Close.add(current_node);
//            //对当前结点进行扩展，得到一个四周结点的数组
//            ArrayList<NavigateNode> neighbour_node = extend_current_node(current_node);
//            //对这个结点遍历，看是否有目标结点出现
//            for (NavigateNode node : neighbour_node) {
//                // G + H + E (对启发函数增加去拐点方案calcNodeExtraCost)
//                int gCost = calcNodeCost(current_node, node) * calcNodeExtraCost(current_node, node, end);
//                if (node.getX() == end.getX() && node.getY() == end.getY()) {//找到目标结点就返回
//                    //init_node操作把这个邻居结点的父节点设置为当前结点
//                    //并且计算出G， F， H等值
//                    node.setLastDistance(gCost);
//                    node.init_node(current_node, end);
//                    return node;
//                }
//
//                //进行计算对G, F, H 等值
//                node.setLastDistance(gCost);
//                node.init_node(current_node, end);
//                node.setH(calcNodeCost(node, end));
//                node.setF(node.getG() + node.getH());
//
//                Open.add(node);
//                Exist.add(node);
//            }
//        }
//        //如果遍历完所有出现的结点都没有找到最终的结点，返回null
//        return null;
//    }
    public NavigateNode astarSearchJava(NavigateNode start, NavigateNode end) {
        //把第一个开始的结点加入到Open表中
        this.Open.add(start);
        //主循环
        while (Open.size() > 0) {
            //取优先队列顶部元素并且把这个元素从Open表中删除
            NavigateNode current_node = Open.poll();

            if (current_node.getX() == end.getX() && current_node.getY() == end.getY()) {//找到目标结点就返回
                return current_node;
            }

            //将这个结点加入到Close表中
            Close.add(current_node);
            //对当前结点进行扩展，得到一个四周结点的数组
            ArrayList<NavigateNode> neighbour_node = extend_current_node(current_node);
            //对这个结点遍历，看是否有目标结点出现
            for (NavigateNode node : neighbour_node) {
                // G + H + E (对启发函数增加去拐点方案calcNodeExtraCost)
                int gCost = calcNodeExtraCost(current_node, node, end);

                //进行计算对G, F, H 等值
                node.setG(1 + gCost);
                node.init_node(current_node, end);
                node.setH(calcNodeCost(node, end));
                node.setF(node.getG() + node.getH());

                String key = node.getX() + "_" + node.getY();
                Integer recordedG = bestGMap.get(key);
                if (recordedG == null || node.getG() <= recordedG) {
                    bestGMap.put(key, node.getG());

                    Open.add(node);
                }
            }
        }
        //如果遍历完所有出现的结点都没有找到最终的结点，返回null
        return null;
    }


    public ArrayList<NavigateNode> extend_current_node(NavigateNode current_node) {
@@ -264,22 +263,9 @@
        if (map[x][y] == MapNodeType.CAR.id) {//节点是小车
            return false;
        }
        NavigateNode navigateNode = new NavigateNode(x, y);
        if (is_exist(navigateNode)) {
            return false;
        }

        //以上情况都没有则合法
        return true;
    }

    public boolean is_exist(NavigateNode node)
    {
        for (NavigateNode exist_node : Exist) {
            if (node.getX() == exist_node.getX() && node.getY() == exist_node.getY()) {
                return true;
            }
        }
        return false;
    }

    //------------------A*启发函数------------------//
@@ -294,12 +280,12 @@
        // 第一个点或直线点
        if (currNode.getFather() == null || nextNode.getX() == currNode.getFather().getX()
                || nextNode.getY() == currNode.getFather().getY()) {
            return 1;
            return 0;
        }

        // 拐向终点的点
        if (nextNode.getX() == endNode.getX() || nextNode.getY() == endNode.getY()) {
            return 2;
            return 1;
        }

        // 普通拐点
@@ -308,7 +294,7 @@
        拿到父节点和下一节点
        通过判断父节点和下一节点的x数据和y数据都不相同时，则表明当前坐标是一个拐点
         */
        return 3;
        return 1;
    }

    //------------------A*启发函数-end------------------//

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -30,6 +30,10 @@
    private String pythonCalcSimilarity;

    public List<NavigateNode> calc(String startPoint, String endPoint, Integer mapType, List<int[]> shuttlePoints, List<int[]> whites) {
        return calcJava(startPoint, endPoint, mapType, shuttlePoints, whites);
    }

    public List<NavigateNode> calcJava(String startPoint, String endPoint, Integer mapType, List<int[]> shuttlePoints, List<int[]> whites) {
        //通过开始编号和结束编号获取对应的xy轴坐标
        int[] startArr = NavigatePositionConvert.positionToXY(startPoint);//开始节点
        int[] endArr = NavigatePositionConvert.positionToXY(endPoint);//结束节点
@@ -52,7 +56,77 @@
        NavigateSolution solution = new NavigateSolution(mapType, lev, whiteList, shuttlePoints);
        //开始节点，不纳入禁用节点内计算

        String pathStr = solution.astarSearch(start, end, pythonCalcPath);
        NavigateNode res_node = solution.astarSearchJava(start, end);
        if (res_node == null) {
            News.error("{} dash {} can't find navigate path!", startPoint, endPoint);
            return null;
        }

        ArrayList<NavigateNode> list = new ArrayList<>();
        //渲染
        NavigateNode fatherNode = null;//当前循环上一节点，用于拐点计算
        while (res_node != null) {
            res_node.setDirection(null);
            res_node.setIsInflectionPoint(false);
            res_node.setZ(lev);//设置层高

            //寻找拐点
            HashMap<String, Object> result = searchInflectionPoint(res_node, fatherNode, res_node.getFather());//分别传入当前节点、父节点、下一节点
            //判断当前节点是否为拐点
            if (Boolean.parseBoolean(result.get("result").toString())) {
                //当前为拐点
                res_node.setIsInflectionPoint(true);
                //拐点方向
                res_node.setDirection(result.get("direction").toString());
            }
            list.add(res_node);

            fatherNode = res_node;//把当前节点保存成一个父节点
            res_node = res_node.getFather();//迭代操作
        }

        Collections.reverse(list);

        //将每个节点里面的fatherNode至为null(方便后续计算时父节点过多导致显示的节点太多)
        for (NavigateNode navigateNode : list) {
            //父节点设置为null，不影响计算结果，不影响后续操作。
            //此操作仅为后续排查处理提供视觉方便。
            navigateNode.setFather(null);
        }

        //起始节点计算方向
        String direction = calcDirection(list.get(0), list.get(1));
        NavigateNode startNode = list.get(0);
        startNode.setDirection(direction);
        //更新节点列表
        list.set(0, startNode);
        return list;
    }

    public List<NavigateNode> calcPython(String startPoint, String endPoint, Integer mapType, List<int[]> shuttlePoints, List<int[]> whites) {
        //通过开始编号和结束编号获取对应的xy轴坐标
        int[] startArr = NavigatePositionConvert.positionToXY(startPoint);//开始节点
        int[] endArr = NavigatePositionConvert.positionToXY(endPoint);//结束节点

        ArrayList<int[]> whiteList = new ArrayList<>();//设置计算节点的白名单
        whiteList.add(startArr);//将开始节点设置为白名单，以防被过滤
        if (whites != null && !whites.isEmpty()) {
            whiteList.addAll(whites);//批量添加白名单节点
        }

        //获取当前节点计算的层高，并赋值到每一个节点中
        int lev = Utils.getLev(startPoint);

        //初始化开始节点
        NavigateNode start = new NavigateNode(startArr[0], startArr[1]);
        //开始节点无父节点
        start.setFather(null);

        NavigateNode end = new NavigateNode(endArr[0], endArr[1]);
        NavigateSolution solution = new NavigateSolution(mapType, lev, whiteList, shuttlePoints);
        //开始节点，不纳入禁用节点内计算

        String pathStr = solution.astarSearchPython(start, end, pythonCalcPath);
        if (pathStr == null) {
            News.error("{} dash {} can't find navigate path!", startPoint, endPoint);
            return null;

 src/main/java/com/zy/common/utils/ShuttleOperaUtils.java

@@ -140,6 +140,18 @@
        return commands;
    }

    /**
     * 获取充电命令
     */
    public synchronized List<ShuttleCommand> shuttleChargeCommand(ShuttleAssignCommand assignCommand, ShuttleThread shuttleThread, Boolean openCharge) {
        List<ShuttleCommand> commands = new ArrayList<>();

        //获取充电命令
        ShuttleCommand command = shuttleThread.getChargeCommand(assignCommand.getDeviceTaskNo(), openCharge);
        commands.add(command);
        return commands;
    }

//    private boolean checkSimilarityPath(Motion motion, ShuttleAssignCommand assignCommand) {
//        String movePath = motion.getMovePath();
//        if (Cools.isEmpty(movePath)) {

 src/main/java/com/zy/core/MainProcess.java

@@ -72,7 +72,7 @@
//                    mainService.ledReset();
                    // 穿梭车 ===>> 小车电量检测充电
                    mainService.loopShuttleCharge();
//                    mainService.executeShuttleCharge();
                    mainService.executeShuttleCharge();

//                    //扫描设备PakMk标记是否超时
//                    mainService.scanDevicePakMk();

 src/main/java/com/zy/core/enums/ShuttleChargeType.java

New file
@@ -0,0 +1,46 @@
package com.zy.core.enums;

import com.core.common.Cools;

public enum ShuttleChargeType {

    CHARGE_1(1, "1402001", "1402001"),
    ;

    ShuttleChargeType(int id, String locNo,String waitLocNo) {
        this.id = id;
        this.locNo = locNo;
        this.waitLocNo = waitLocNo;
    }

    public int id;
    public String locNo;
    public String waitLocNo;

    public static ShuttleChargeType get(String locNo) {
        if (Cools.isEmpty(locNo)) {
            return null;
        }
        ShuttleChargeType[] values = ShuttleChargeType.values();
        for (ShuttleChargeType value : values) {
            if (value.locNo.equals(locNo)) {
                return value;
            }
        }
        return null;
    }

    public static ShuttleChargeType get(int id) {
        if (Cools.isEmpty(id)) {
            return null;
        }
        ShuttleChargeType[] values = ShuttleChargeType.values();
        for (ShuttleChargeType value : values) {
            if (value.id == id) {
                return value;
            }
        }
        return null;
    }

}

 src/main/java/com/zy/core/enums/WrkIoType.java

New file
@@ -0,0 +1,48 @@
package com.zy.core.enums;

import com.core.common.Cools;

public enum WrkIoType {

    IN(1, "入库"),
    OUT(101, "出库"),
    SHUTTLE_MOVE(200, "小车移动"),
    SHUTTLE_CHARGE(300, "小车充电"),
    ;

    WrkIoType(int id, String desc) {
        this.id = id;
        this.desc = desc;
    }

    public int id;

    public String desc;

    public static WrkIoType get(String desc) {
        if (Cools.isEmpty(desc)) {
            return null;
        }
        WrkIoType[] values = WrkIoType.values();
        for (WrkIoType value : values) {
            if (value.desc.equals(desc)) {
                return value;
            }
        }
        return null;
    }

    public static WrkIoType get(int id) {
        if (Cools.isEmpty(id)) {
            return null;
        }
        WrkIoType[] values = WrkIoType.values();
        for (WrkIoType value : values) {
            if (value.id == id) {
                return value;
            }
        }
        return null;
    }

}

 src/main/java/com/zy/core/enums/WrkStsType.java

@@ -22,9 +22,10 @@
    SETTLE_OUTBOUND(110, "出库库存更新"),

    NEW_CHARGE(201, "生成充电任务"),
    CHARGE_SHUTTLE_RUN(202, "小车去充电中"),
    CHARGE_SHUTTLE_WORKING(203, "执行充电任务"),
    CHARGE_SHUTTLE_COMPLETE(204, "小车充电完成"),
    CHARGE_SHUTTLE_RUN(202, "小车前往充电桩"),
    CHARGE_SHUTTLE_RUN_COMPLETE(203, "小车到达充电桩"),
    CHARGE_SHUTTLE_WORKING(204, "小车充电中"),
    CHARGE_SHUTTLE_COMPLETE(205, "小车充电完成"),
    COMPLETE_CHARGE(210, "充电任务完成"),

    NEW_MOVE(301, "生成迁移任务"),

 src/main/resources/mapper/WrkMastMapper.xml

@@ -168,4 +168,11 @@
        order by priority desc,start_time,wrk_no asc
    </select>

    <select id="selectChargeWorkingByChargeSta" resultMap="BaseResultMap">
        select * from asr_wrk_mast
        where wrk_sts in (201,202,203)
        and mk = #{chargeSta}
        order by priority desc,start_time,wrk_no asc
    </select>

</mapper>