#

Junjie

2025-04-10 1d624dfdb040825ffecba6c792c480be662b2dbc

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

@@ -1,13 +1,27 @@
package com.zy.asrs.utils;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Arith;

import java.math.BigDecimal;
import com.core.common.Cools;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.utils.NavigatePositionConvert;
import com.zy.common.utils.NavigateUtils;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.ShuttleSlave;
import com.zy.core.model.protocol.ShuttleProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.ShuttleThread;
import java.text.DecimalFormat;
import java.util.*;

/**
 * Created by vincent on 2020/8/27
 */
public class Utils {

    private static final DecimalFormat fmt = new DecimalFormat("##0.00");
@@ -19,4 +33,228 @@
        return (float) Arith.multiplys(2, f, 1);
    }

    public static String zerofill(String msg, Integer count){
        if (msg.length() == count){
            return msg;
        } else if (msg.length() > count){
            return msg.substring(0, 16);
        } else {
            StringBuilder msgBuilder = new StringBuilder(msg);
            for (int i = 0; i<count-msg.length(); i++){
                msgBuilder.insert(0,"0");
            }
            return msgBuilder.toString();
        }
    }

    /**
     * 通过库位号获取 排
     */
    public static int getRow(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(0, 2));
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 通过库位号获取 列
     */
    public static int getBay(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(2, 5));
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 通过库位号获取 层
     */
    public static int getLev(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(5, 7));
        }
        throw new RuntimeException("库位解析异常");
    }

    public static String getLocNo(Number row, Number bay, Number lev) {
        return zerofill(String.valueOf(row), 2) + zerofill(String.valueOf(bay), 3) + zerofill(String.valueOf(lev), 2);
    }

    public static List<String> getGroupLoc(String locNo) {
        return null;
    }

    //获取除白名单外的指定楼层全部穿梭车xy坐标点
    public static int[] getShuttlePoint(Integer shuttleNo) {
        //获取穿梭车所在节点位置
        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
        if (shuttleThread == null) {
            return null;
        }
        ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
        if (shuttleProtocol == null) {
            return null;
        }

        String currentLocNo = shuttleProtocol.getCurrentLocNo();
        if (currentLocNo == null) {
            return null;
        }

        if (shuttleProtocol.getCurrentLocNo() == null) {
            return null;
        }
        return NavigatePositionConvert.positionToXY(shuttleProtocol.getCurrentLocNo());
    }

    //获取除白名单外的指定楼层全部穿梭车xy坐标点
    public static List<int[]> getShuttlePoints(Integer whiteShuttle, Integer lev) {
        SlaveProperties slaveProperties = SpringUtils.getBean(SlaveProperties.class);
        ArrayList<int[]> list = new ArrayList<>();
        for (ShuttleSlave slave : slaveProperties.getShuttle()) {
            if (slave.getId().intValue() == whiteShuttle) {
                continue;//跳过白名单
            }

            //获取穿梭车所在节点位置
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }

            String currentLocNo = shuttleProtocol.getCurrentLocNo();
            if (currentLocNo == null) {
                continue;
            }

            if (lev != Utils.getLev(currentLocNo)) {
                continue;//楼层不同
            }

            if (shuttleProtocol.getCurrentLocNo() == null) {
                continue;
            }
            int[] xyPosition = NavigatePositionConvert.positionToXY(shuttleProtocol.getCurrentLocNo());//通过库位号获取xy坐标
            list.add(xyPosition);
        }
        return list;
    }

    //检测楼层是否有可用穿梭车
    public static boolean checkLevHasShuttle(Integer lev) {
        SlaveProperties slaveProperties = SpringUtils.getBean(SlaveProperties.class);
        WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);
        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }
            String currentLocNo = shuttleProtocol.getCurrentLocNo();
            if (currentLocNo == null) {
                continue;
            }

            //小车正在充电
            if (shuttleThread.isCharging()) {
                continue;
            }

            //小车有充电任务
            WrkMast chargeWorking = wrkMastService.selectChargeWorking(shuttleProtocol.getShuttleNo());
            if (chargeWorking != null) {//已有充电任务
                continue;
            }

            //小车处于故障状态
            if (shuttleThread.isFault()) {
                continue;
            }

            if (lev == Utils.getLev(currentLocNo)) {
                return true;//指定楼层有穿梭车
            }
        }

        return false;//指定楼层没有穿梭车
    }

    //检测库位组是否存在小车，存在返回小车号。
    public static Integer checkGroupLocHasShuttle(List<String> groupLoc) {
        if (groupLoc == null) {
            return null;
        }

        if (groupLoc.isEmpty()) {
            return null;
        }

        SlaveProperties slaveProperties = SpringUtils.getBean(SlaveProperties.class);
        if (slaveProperties == null) {
            return null;
        }

        for (String loc : groupLoc) {
            for (ShuttleSlave slave : slaveProperties.getShuttle()) {
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
                if (shuttleThread == null) {
                    continue;
                }

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

                if (shuttleProtocol.getCurrentLocNo() == null) {
                    continue;
                }

                if (shuttleProtocol.getCurrentLocNo().equals(loc)) {
                    //存在小车
                    return slave.getId();
                }
            }
        }

        return null;
    }

    //获取小车待机位
    public static String getShuttleStandbyLocNo(String locNo) {
        LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
                .eq("loc_type", "standby")
                .eq("lev1", Utils.getLev(locNo)));
        if (locMasts.isEmpty()) {
            return null;
        }

        Integer recentDistance = Integer.MAX_VALUE;
        String recentLocNo = null;
        for (LocMast locMast : locMasts) {
            //待机位到目标点距离
            List<NavigateNode> currentShuttlePath = navigateUtils.calc(locNo, locMast.getLocNo(), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(0, Utils.getLev(locNo)), null);//搜索空闲穿梭车，使用正常通道地图
            if (currentShuttlePath == null) {
                continue;
            }
            Integer currentAllDistance = navigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
            if (currentAllDistance < recentDistance) {
                recentDistance = currentAllDistance;
                recentLocNo = locMast.getLocNo();
            }
        }

        return recentLocNo;
    }
}