#出库找待机位优化

zjj

7 天以前 314729da5f6f84a6112344a2210aadfeeb2bac0c

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/utils/ShuttleDispatcher.java

@@ -6,27 +6,26 @@
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.common.SnowflakeIdWorker;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wcs.core.entity.BasShuttle;
import com.zy.asrs.wcs.core.entity.Task;
import com.zy.asrs.wcs.core.entity.*;
import com.zy.asrs.wcs.core.kernel.AnalyzeService;
import com.zy.asrs.wcs.core.model.NavigateNode;
import com.zy.asrs.wcs.core.model.enums.LiftCodeType;
import com.zy.asrs.wcs.core.model.enums.NavigationMapType;
import com.zy.asrs.wcs.core.service.BasShuttleService;
import com.zy.asrs.wcs.core.service.TaskService;
import com.zy.asrs.wcs.core.model.enums.*;
import com.zy.asrs.wcs.core.service.*;
import com.zy.asrs.wcs.rcs.News;
import com.zy.asrs.wcs.rcs.cache.SlaveConnection;
import com.zy.asrs.wcs.rcs.entity.Device;
import com.zy.asrs.wcs.rcs.entity.DeviceType;
import com.zy.asrs.wcs.rcs.model.enums.ShuttleProtocolStatusType;
import com.zy.asrs.wcs.rcs.model.enums.SlaveType;
import com.zy.asrs.wcs.rcs.model.protocol.ShuttleProtocol;
import com.zy.asrs.wcs.rcs.service.DeviceService;
import com.zy.asrs.wcs.rcs.service.DeviceTypeService;
import com.zy.asrs.wcs.core.service.MotionService;
import com.zy.asrs.wcs.rcs.thread.LiftThread;
import com.zy.asrs.wcs.rcs.thread.ShuttleThread;
import com.zy.asrs.wcs.system.entity.Dict;
import com.zy.asrs.wcs.system.service.DictService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.*;

/**
 * Created by vincent on 2023/10/12
@@ -43,8 +42,6 @@
    private LiftDispatcher liftDispatcher;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
//    @Autowired
//    private CommonService commonService;
    @Autowired
    private AnalyzeService analyzeService;
    @Autowired
@@ -52,25 +49,24 @@
    @Autowired
    private DeviceService deviceService;
    @Autowired
    private DeviceTypeService deviceTypeService;
    @Autowired
    private BasShuttleService basShuttleService;
    @Autowired
    private TaskCtgService taskCtgService;
    @Autowired
    private ShuttleStandbyService shuttleStandbyService;
    @Autowired
    private DictService dictService;

    public ShuttleThread queryShuttleWhichConvenient(Task task, Integer liftNo) {
    public synchronized ShuttleThread searchIdleShuttle(Task task) {
        String locNo = taskService.judgeInbound(task) ? task.getDestLoc() : task.getOriginLoc();
        ShuttleThread resThread = null;
        Integer finalDistance = ShuttleDispatcher.INF;

        DeviceType deviceType = deviceTypeService.getOne(new LambdaQueryWrapper<DeviceType>()
                .eq(DeviceType::getHostId, task.getHostId())
                .eq(DeviceType::getStatus, 1)
                .eq(DeviceType::getFlag, String.valueOf(SlaveType.Shuttle)));
        if (deviceType == null) {
            throw new CoolException("设备类型不存在");
        }
        //检测目标楼层车数量是否小于允许的最大数量
        boolean checkDispatchMaxNum = checkDispatchMaxNum(Utils.getLev(locNo), task.getHostId());

        List<Device> list = deviceService.list(new LambdaQueryWrapper<Device>()
                .eq(Device::getDeviceType, deviceType.getId())
                .eq(Device::getDeviceType, DeviceCtgType.SHUTTLE.val())
                .eq(Device::getHostId, task.getHostId())
                .eq(Device::getStatus, 1));

@@ -89,6 +85,21 @@
                continue;
            }

            BasShuttle basShuttle = basShuttleService.getOne(new LambdaQueryWrapper<BasShuttle>()
                    .eq(BasShuttle::getShuttleNo, device.getDeviceNo())
                    .eq(BasShuttle::getHostId, device.getHostId()));
            if (basShuttle == null) {
                continue;//小车基础数据不存在
            }

            if (!Cools.isEmpty(basShuttle.getDisableLev())) {
                List<Integer> disableLev = JSON.parseArray(basShuttle.getDisableLev(), Integer.class);
                //检查小车是否禁用该楼层
                if (disableLev.contains(Utils.getLev(locNo))) {
                    continue;//小车禁用该楼层跳过该车
                }
            }

            //检测是否存在充电任务
            Task taskCharge = taskService.selectChargeWorking(Integer.valueOf(device.getDeviceNo()));
            if (taskCharge != null) {
@@ -104,10 +115,29 @@
                break;
            }

            String targetLocNo = LiftCodeType.getStandbyLocNo(liftNo, currentLev);//默认到提升机待机位
            String targetLocNo = null;//默认到提升机待机位
            // 同楼层直接计算到目标库位
            if (currentLev == Utils.getLev(locNo)) {
                targetLocNo = locNo;
            }else {
                if (!checkDispatchMaxNum) {
                    News.info("{}任务，{}层，已经达到当前楼层调度车辆最大值", task.getTaskNo(), Utils.getLev(locNo));
                    continue;
                }

                //获取距离目标位置最近的空闲可换层提升机
                LiftThread liftThread = liftDispatcher.searchIdleLift(locNo, task.getHostId(), true);
                if (liftThread == null) {
                    continue;
                }
                Device recentTransferLift = liftThread.getDevice();

                //获取小车楼层提升机待机位
                ShuttleStandby shuttleStandby = shuttleStandbyService.getOne(new LambdaQueryWrapper<ShuttleStandby>()
                        .eq(ShuttleStandby::getDeviceId, recentTransferLift.getId())
                        .eq(ShuttleStandby::getDeviceLev, currentLev)
                        .eq(ShuttleStandby::getStatus, 1));
                targetLocNo = shuttleStandby.getDeviceLoc();
            }

            //当前穿梭车线程到当前车子所在楼层的提升机口距离
@@ -129,7 +159,7 @@
            }

            // 挂载任务权重
            List<Task> tasks = taskService.selectWorkingByShuttle(Integer.valueOf(device.getDeviceNo()));
            List<Task> tasks = taskService.selectWorkingByShuttle(Integer.valueOf(device.getDeviceNo()), null);
            if (!Cools.isEmpty(tasks)) {
                currDistance += tasks.size() * WEIGHT;
            }
@@ -141,6 +171,116 @@
        }

        return resThread;
    }

    //生成迁移任务
    public synchronized Task generateMoveTask(Device device, String locNo) {
        // 已有迁移任务
        if (taskService.selectMoveWorking(Integer.valueOf(device.getDeviceNo())) != null) {
            return null;
        }

        //获取迁移任务类型
        TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MOVE))
                .eq(TaskCtg::getStatus, 1));
        if (taskCtg == null) {
            return null;
        }

        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
        if (shuttleThread == null) {
            return null;
        }

        Task task = new Task();
        task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        task.setTaskNo(String.valueOf(Utils.getTaskNo("MOVE")));
        task.setTaskSts(TaskStsType.NEW_MOVE.sts);
        task.setTaskCtg(taskCtg.getId());
        task.setPriority(10);
        task.setOriginSite(null);
        task.setOriginLoc(null);
        task.setDestSite(null);
        task.setDestLoc(locNo); // 迁移位置
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setHostId(device.getHostId());
        task.setStatus(1);
        task.setShuttleNo(Integer.valueOf(device.getDeviceNo()));

        // generate motion list
        List<Motion> motionList = analyzeService.generateShuttleMoveMotion(task);
        if (Cools.isEmpty(motionList)) {
            News.error("保存{}号四向穿梭车迁移任务失败!!!", device.getDeviceNo());
            return null;
        }
        motionService.batchInsert(motionList, task.getUuid(), Integer.valueOf(task.getTaskNo()), device.getHostId());

        task.setTaskSts(TaskStsType.ANALYZE_MOVE.sts);

        if (!taskService.save(task)) {
            News.error("保存{}号四向穿梭车迁移任务失败!!!", device.getDeviceNo());
            return null;
        }

        return task;
    }

    //生成手动取放货任务
    public synchronized Task generateManuaTakeMoveTask(Device device, String sourceLocNo, String locNo) {
        // 已有手动任务
        if (taskService.selectManualWorking(Integer.valueOf(device.getDeviceNo())) != null) {
            return null;
        }

        //获取手动任务类型
        TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MANUAL))
                .eq(TaskCtg::getStatus, 1));
        if (taskCtg == null) {
            return null;
        }

        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
        if (shuttleThread == null) {
            return null;
        }

        Task task = new Task();
        task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        task.setTaskNo(String.valueOf(Utils.getTaskNo("MANUAL")));
        task.setTaskSts(TaskStsType.NEW_MANUAL.sts);
        task.setTaskCtg(taskCtg.getId());
        task.setPriority(10);
        task.setOriginSite(null);
        task.setOriginLoc(sourceLocNo);
        task.setDestSite("takeMove");
        task.setDestLoc(locNo);
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo("manual");
        task.setShuttleNo(Integer.valueOf(device.getDeviceNo()));
        task.setRecordLoc("Y");//记录库存信息
        task.setHostId(device.getHostId());

        // generate motion list
        List<Motion> motionList = analyzeService.generateShuttleManualMotion(task);
        if (Cools.isEmpty(motionList)) {
            News.error("保存{}号四向穿梭车手动任务失败!!!", device.getDeviceNo());
            return null;
        }
        motionService.batchInsert(motionList, task.getUuid(), Integer.valueOf(task.getTaskNo()), device.getHostId());

        task.setTaskSts(TaskStsType.ANALYZE_MANUAL.sts);

        if (!taskService.save(task)) {
            News.error("保存{}号四向穿梭车手动任务失败!!!", device.getDeviceNo());
            return null;
        }

        return task;
    }

    /**
@@ -160,20 +300,24 @@
        }

        int lev = Utils.getLev(locNo);//当前楼层
        JSONArray standbyLoc = JSON.parseArray(idleLoc);
        if (lev > standbyLoc.size()) {
        List<String> standbyLoc = JSON.parseArray(idleLoc, String.class);
        if (standbyLoc.isEmpty()) {
            throw new CoolException("避让数据异常");
        }

        Object object = standbyLoc.get(lev - 1);
        List<String> locs = JSON.parseArray(object.toString(), String.class);
        if (locs.isEmpty()) {
            throw new CoolException("避让数据为空");
        //获取当前层避让位置
        List<String> currentLevStandByLoc = new ArrayList<>();
        for (String loc : standbyLoc) {
            if (Utils.getLev(loc) == lev) {
                currentLevStandByLoc.add(loc);
            }
        }
        if (currentLevStandByLoc.isEmpty()) {
            throw new CoolException("当前层无避让位置");
        }

        Integer finalDistance = ShuttleDispatcher.INF;
        String recentLoc = null;
        for (String loc : locs) {
        for (String loc : currentLevStandByLoc) {
            //当前穿梭车到避让位计算
            List<NavigateNode> currentShuttlePath = NavigateUtils.calc(
                    locNo
@@ -199,5 +343,170 @@
        return recentLoc;
    }

    /**
     * 搜索可用库位，通过小车号和目标库位
     */
    public String searchAvailableLocNo(Integer shuttleNo, Long hostId, String currentLocNo, List<String> locNos) {
        BasShuttle basShuttle = basShuttleService.getOne(new LambdaQueryWrapper<BasShuttle>()
                .eq(BasShuttle::getShuttleNo, shuttleNo)
                .eq(BasShuttle::getHostId, hostId));
        if (basShuttle == null) {
            throw new CoolException("小车基础数据不存在");
        }

        if (locNos.isEmpty()) {
            throw new CoolException("当前层无避让位置");
        }

        int lev = Utils.getLev(currentLocNo);

        Integer finalDistance = ShuttleDispatcher.INF;
        String recentLoc = null;
        for (String loc : locNos) {
            //当前穿梭车到避让位计算
            List<NavigateNode> currentShuttlePath = NavigateUtils.calc(
                    currentLocNo
                    , loc
                    , NavigationMapType.NORMAL.id
                    , Utils.getShuttlePoints(shuttleNo, lev)
            );//使用正常通道地图
            if (currentShuttlePath == null) {
                continue;
            }

            Integer currDistance = NavigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
            if (currDistance < finalDistance) {
                finalDistance = currDistance;
                recentLoc = loc;
            }
        }

        if (recentLoc == null) {
            throw new CoolException("搜索避让位置失败");
        }

        return recentLoc;
    }

    /**
     * 检测目标楼层车数量是否小于允许的最大数量
     * true: 小于最大数量  false: 大于或等于最大数量
     */
    public boolean checkDispatchMaxNum(Integer lev, Long hostId) {
        Dict dict = dictService.getOne(new LambdaQueryWrapper<Dict>().eq(Dict::getFlag, "dispatchShuttleMaxNum"));
        if (dict == null) {
            return false;
        }

        int levCount = 0;//目标楼层车辆数量
        List<Device> list = deviceService.list(new LambdaQueryWrapper<Device>()
                .eq(Device::getDeviceType, DeviceCtgType.SHUTTLE.val())
                .eq(Device::getHostId, hostId)
                .eq(Device::getStatus, 1));

        for (Device device : list) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
            if (shuttleThread == null) {
                continue;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }
            if (shuttleProtocol.getProtocolStatusType() == ShuttleProtocolStatusType.OFFLINE){
                continue;
            }

            if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) == lev) {
                if (shuttleProtocol.getHasCharge()) {
                    continue;//充电中
                }

                levCount++;//目标楼层有车，数量增加
            }
        }

        //搜索是否存在前往目标楼层的小车移动工作档
        for (Task task : taskService.list(new LambdaQueryWrapper<Task>()
                .in(Task::getTaskSts, TaskStsType.NEW_MOVE.sts, TaskStsType.ANALYZE_MOVE.sts, TaskStsType.EXECUTE_MOVE.sts, TaskStsType.COMPLETE_MOVE.sts))) {
            if (task.getOriginLoc() == null || task.getDestLoc() == null) {
                continue;
            }

            int sourceLev = Utils.getLev(task.getOriginLoc());//工作档源楼层
            int targetLev = Utils.getLev(task.getDestLoc());//工作档目标楼层
            if (sourceLev == targetLev) {
                continue;//工作档楼层和目标楼层相同，跳过
            }

            if (targetLev == lev) {
                levCount++;//工作档目标楼层和实际楼层相同，数量增加
                continue;
            }

        }

        //搜索是否存在前往目标楼层的小车工作档
        for (Task task : taskService.list(new LambdaQueryWrapper<Task>()
                .in(Task::getTaskSts, TaskStsType.NEW_INBOUND.sts, TaskStsType.ANALYZE_INBOUND.sts, TaskStsType.EXECUTE_INBOUND.sts, TaskStsType.COMPLETE_INBOUND.sts
                        , TaskStsType.NEW_OUTBOUND.sts, TaskStsType.ANALYZE_OUTBOUND.sts, TaskStsType.EXECUTE_OUTBOUND.sts, TaskStsType.COMPLETE_OUTBOUND.sts))) {

            List<Motion> motions = motionService.list(new LambdaQueryWrapper<Motion>()
                    .eq(Motion::getTaskNo, task.getTaskNo())
                    .in(Motion::getMotionCtg, MotionCtgType.SHUTTLE_MOVE
                            , MotionCtgType.SHUTTLE_MOVE_LIFT_PALLET
                            , MotionCtgType.SHUTTLE_MOVE_DOWN_PALLET
                            , MotionCtgType.SHUTTLE_MOVE_FROM_LIFT
                            , MotionCtgType.SHUTTLE_MOVE_TO_LIFT
                            , MotionCtgType.SHUTTLE_MOVE_FROM_CONVEYOR
                            , MotionCtgType.SHUTTLE_MOVE_TO_CONVEYOR
                            , MotionCtgType.SHUTTLE_MOVE_FROM_LIFT_TO_CONVEYOR
                    ));

            boolean isUpdateLev = false;
            for (Motion motion : motions) {
                if (motion.getOrigin() == null || motion.getTarget() == null) {
                    continue;
                }

                int sourceLev = Utils.getLev(motion.getOrigin());//动作源楼层
                int targetLev = Utils.getLev(motion.getTarget());//动作目标楼层
                if (sourceLev != targetLev) {
                    isUpdateLev = true;
                    break;
                }
            }

            if(isUpdateLev) {
                levCount++;//工作档属于跨层任务，小车归属于目标楼层
                continue;
            }

        }

        return levCount < Integer.parseInt(dict.getValue());
    }
    //分析出库路径待机库位
    public String analyzeOutPathWaitLoc(String startLoc, String targetLoc, Device shuttleDevice) {
        //计算路径并分解成两段动作
        List<NavigateNode> nodeList = NavigateUtils.calc(startLoc, targetLoc, NavigationMapType.DFX.id, Utils.getShuttlePoints(Integer.parseInt(shuttleDevice.getDeviceNo()), Utils.getLev(startLoc)));
        if (nodeList == null) {
            News.error("{} dash {} can't find navigate path!", startLoc, targetLoc);
            return null;
        }
        //获取分段路径
        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(nodeList);
        if (data.size() <= 1) {
            return null;//两点之间只有一段路径
        }

        //取出倒数第二段路径
        ArrayList<NavigateNode> navigateNodes = data.get(data.size() - 2);
        NavigateNode startNode = navigateNodes.get(0);
        String lastPathStartLoc = Utils.getLocNo(startNode.getX(), startNode.getY(), startNode.getZ());
        return lastPathStartLoc;
    }

}