package com.zy.core.dispatcher;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.core.common.Cools;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.domain.ShuttleGatherResult;
|
import com.zy.asrs.domain.param.ShuttleGatherParam;
|
import com.zy.asrs.entity.BasShuttle;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.asrs.service.BasShuttleService;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.asrs.utils.Utils;
|
import com.zy.common.model.NavigateNode;
|
import com.zy.common.model.enums.NavigationMapType;
|
import com.zy.common.service.CommonService;
|
import com.zy.common.utils.NavigateUtils;
|
import com.zy.core.News;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.enums.WrkIoType;
|
import com.zy.core.enums.WrkStsType;
|
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 com.zy.system.entity.Config;
|
import com.zy.system.service.ConfigService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.rmi.CORBA.Util;
|
import java.util.*;
|
|
/**
|
* 四向穿梭车调度工具
|
*/
|
@Service
|
public class ShuttleDispatchUtils {
|
|
@Autowired
|
private SlaveProperties slaveProperties;
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private NavigateUtils navigateUtils;
|
@Autowired
|
private ConfigService configService;
|
@Autowired
|
private BasShuttleService basShuttleService;
|
|
/**
|
* 调度车辆-调度指定穿梭车
|
*/
|
public boolean dispatchShuttle(Integer wrkNo, String sourceLocNo, String locNo, Integer shuttleNo, String flag) {
|
return shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
|
}
|
|
/**
|
* 调度车辆-调度指定穿梭车
|
*/
|
public boolean dispatchShuttle(Integer wrkNo, String locNo, Integer shuttleNo) {
|
return shuttleMoveGenerate(wrkNo, locNo, shuttleNo);
|
}
|
|
/**
|
* 调度车辆
|
*/
|
public boolean searchDispatchShuttle(Integer wrkNo, String sourceLocNo, String locNo, String flag) {
|
ArrayList<ShuttleThread> sameLev = new ArrayList<>();//相同楼层的穿梭车
|
ArrayList<ShuttleThread> diffLev = new ArrayList<>();//不同楼层的穿梭车
|
|
for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
|
//获取四向穿梭车线程
|
ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
if (shuttleProtocol == null || shuttleProtocol.getShuttleNo() == null) {
|
continue;
|
}
|
|
if (checkChargeWrk(shuttle.getId())) {
|
continue;//存在充电任务，过滤小车
|
}
|
|
if (!shuttleThread.isIdle()) {
|
continue;//小车忙碌中
|
}
|
|
BasShuttle basShuttle = basShuttleService.selectOne(new EntityWrapper<BasShuttle>().eq("shuttle_no", shuttle.getId()));
|
if (basShuttle != null) {
|
if (basShuttle.getStatus() == 0) {
|
continue;//小车被禁用
|
}
|
}
|
|
int currentLev = Utils.getLev(shuttleProtocol.getCurrentLocNo());//小车当前层高
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();//小车当前库位号
|
|
if (currentLocNo.equals(locNo)) {
|
//车辆当前位置已经是目标库位，调度该车
|
//给工作档绑定小车号
|
WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkNo);
|
if (wrkMast1 != null) {
|
wrkMast1.setShuttleNo(shuttleProtocol.getShuttleNo());
|
wrkMastService.updateById(wrkMast1);
|
return true;
|
}
|
break;
|
}
|
|
if (currentLev == Utils.getLev(locNo)) {
|
//工作档楼层相同的穿梭车
|
sameLev.add(shuttleThread);
|
} else {
|
//工作档不同楼层的穿梭车
|
diffLev.add(shuttleThread);
|
}
|
|
}
|
|
//优先调度同楼层小车，寻找离任务最近的穿梭车
|
if (!sameLev.isEmpty()) {
|
Map<Integer, ShuttleThread> sameShuttles = new TreeMap<>();//自然排序小车Map
|
for (ShuttleThread shuttleThread : sameLev) {
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//当前穿梭车库位号
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
if (currentLocNo.equals(locNo)) {
|
sameShuttles.put(-1, shuttleThread);
|
continue;
|
}
|
|
//当前穿梭车线程到目标地点距离
|
List<NavigateNode> currentShuttlePath = navigateUtils.calc(currentLocNo, locNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleNo, Utils.getLev(currentLocNo)), null);//搜索空闲穿梭车，使用正常通道地图
|
if (currentShuttlePath == null) {
|
continue;
|
}
|
Integer currentAllDistance = navigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
|
sameShuttles.put(currentAllDistance, shuttleThread);
|
}
|
|
//尝试调度同楼层小车
|
for (Map.Entry<Integer, ShuttleThread> entry : sameShuttles.entrySet()) {
|
ShuttleThread shuttleThread = entry.getValue();
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//尝试调度小车
|
boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
|
if (result) {
|
return true;//调度成功
|
}
|
}
|
}
|
|
//执行到此处，同楼层无调度成功小车。需要进行跨楼层调度小车
|
//寻找离任务楼层最近的穿梭车(不考虑跨楼层小车移动距离)
|
if (!diffLev.isEmpty()) {
|
Map<Integer, ShuttleThread> diffShuttles = new TreeMap<>();//自然排序小车Map
|
//获取任务
|
WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkNo);
|
if (wrkMast1 != null) {
|
String targetLoc = wrkMast1.getIoType() < 100 ? wrkMast1.getLocNo() : wrkMast1.getSourceLocNo();
|
int lev = Utils.getLev(targetLoc);//目标楼层
|
|
//检测目标楼层车数量是否小于允许的最大数量
|
boolean checkDispatchMaxNum = checkDispatchMaxNum(lev);
|
if (!checkDispatchMaxNum) {
|
News.info("{}任务，{}层，已经达到当前楼层调度车辆最大值", wrkMast1.getWrkNo(), lev);
|
return false;
|
}
|
|
for (ShuttleThread shuttleThread : diffLev) {
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
//当前穿梭车库位号
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
int currentLev = Utils.getLev(currentLocNo);
|
// List<WrkMast> wrkMasts1 = wrkMastService.selectNoShuttleWrkByLev(currentLev);//判断当前穿梭车楼层是否有待分配车辆的任务，如果有则不分配这辆车
|
// int shuttleCount = this.getShuttleCountByLev(currentLev);//获取穿梭车楼层车辆数量
|
// if (!wrkMasts1.isEmpty() && shuttleCount <= 1) {
|
// //存在其他任务且可用小车数量小于等于1，跳过这辆车
|
// continue;
|
// }
|
|
//ABS(目标楼层 - 当前楼层) 得到差距，取最小差值
|
int currentValue = Math.abs(lev - currentLev);
|
if (diffShuttles.get(currentValue) != null) {
|
diffShuttles.put(currentValue + 1, shuttleThread);
|
} else {
|
diffShuttles.put(currentValue, shuttleThread);
|
}
|
}
|
|
//尝试调度跨楼层小车
|
for (Map.Entry<Integer, ShuttleThread> entry : diffShuttles.entrySet()) {
|
ShuttleThread shuttleThread = entry.getValue();
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//尝试调度小车
|
boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
|
if (result) {
|
return true;//调度成功
|
}
|
}
|
}
|
}
|
|
//News.info("{}目标库位没有搜索到可用穿梭车", locNo);
|
return false;
|
}
|
|
/**
|
* 调度车辆
|
*/
|
public boolean searchDispatchShuttleS(Integer wrkNo, String sourceLocNo, String locNo, String flag) {
|
ArrayList<ShuttleThread> sameLev = new ArrayList<>();//相同楼层的穿梭车
|
ArrayList<ShuttleThread> diffLev = new ArrayList<>();//不同楼层的穿梭车
|
|
for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
|
//获取四向穿梭车线程
|
ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
if (shuttleProtocol == null || shuttleProtocol.getShuttleNo() == null) {
|
continue;
|
}
|
|
if (checkChargeWrk(shuttle.getId())) {
|
continue;//存在充电任务，过滤小车
|
}
|
|
if (!shuttleThread.isIdle()) {
|
continue;//小车忙碌中
|
}
|
|
BasShuttle basShuttle = basShuttleService.selectOne(new EntityWrapper<BasShuttle>().eq("shuttle_no", shuttle.getId()));
|
if (basShuttle != null) {
|
if (basShuttle.getStatus() == 0) {
|
continue;//小车被禁用
|
}
|
}
|
|
int currentLev = Utils.getLev(shuttleProtocol.getCurrentLocNo());//小车当前层高
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();//小车当前库位号
|
|
if (currentLocNo.equals(locNo) || currentLocNo.equals(sourceLocNo)) {
|
//车辆当前位置已经是目标库位，调度该车
|
//给工作档绑定小车号
|
WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkNo);
|
if (wrkMast1 != null) {
|
wrkMast1.setShuttleNo(shuttleProtocol.getShuttleNo());
|
wrkMastService.updateById(wrkMast1);
|
sameLev.add(0, shuttleThread);
|
//return true;
|
}
|
break;
|
}
|
if (currentLev == Utils.getLev(sourceLocNo)) {
|
//工作档楼层相同的穿梭车
|
sameLev.add(shuttleThread);
|
} else {
|
//工作档不同楼层的穿梭车
|
diffLev.add(shuttleThread);
|
}
|
|
|
}
|
|
//优先调度同楼层小车，寻找离任务最近的穿梭车
|
if (!sameLev.isEmpty()) {
|
Map<Integer, ShuttleThread> sameShuttles = new TreeMap<>();//自然排序小车Map
|
for (ShuttleThread shuttleThread : sameLev) {
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//当前穿梭车库位号
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
if (currentLocNo.equals(sourceLocNo)) {
|
sameShuttles.put(-1, shuttleThread);
|
continue;
|
}
|
|
//当前穿梭车线程到目标地点距离
|
List<NavigateNode> currentShuttlePath = navigateUtils.calc(currentLocNo, locNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleNo, Utils.getLev(currentLocNo)), null);//搜索空闲穿梭车，使用正常通道地图
|
if (currentShuttlePath == null) {
|
continue;
|
}
|
|
Integer currentAllDistance = navigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
|
sameShuttles.put(currentAllDistance, shuttleThread);
|
}
|
|
//尝试调度同楼层小车
|
for (Map.Entry<Integer, ShuttleThread> entry : sameShuttles.entrySet()) {
|
ShuttleThread shuttleThread = entry.getValue();
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//尝试调度小车
|
boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
|
if (result) {
|
return true;//调度成功
|
}
|
}
|
}
|
|
//执行到此处，同楼层无调度成功小车。需要进行跨楼层调度小车
|
//寻找离任务楼层最近的穿梭车(不考虑跨楼层小车移动距离)
|
if (!diffLev.isEmpty()) {
|
Map<Integer, ShuttleThread> diffShuttles = new TreeMap<>();//自然排序小车Map
|
//获取任务
|
WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkNo);
|
if (wrkMast1 != null) {
|
String targetLoc = wrkMast1.getIoType() < 100 ? wrkMast1.getLocNo() : wrkMast1.getSourceLocNo();
|
int lev = Utils.getLev(targetLoc);//目标楼层
|
|
//检测目标楼层车数量是否小于允许的最大数量
|
boolean checkDispatchMaxNum = checkDispatchMaxNum(lev);
|
if (!checkDispatchMaxNum) {
|
News.info("{}任务，{}层，已经达到当前楼层调度车辆最大值", wrkMast1.getWrkNo(), lev);
|
return false;
|
}
|
|
for (ShuttleThread shuttleThread : diffLev) {
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
//当前穿梭车库位号
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
int currentLev = Utils.getLev(currentLocNo);
|
// List<WrkMast> wrkMasts1 = wrkMastService.selectNoShuttleWrkByLev(currentLev);//判断当前穿梭车楼层是否有待分配车辆的任务，如果有则不分配这辆车
|
// int shuttleCount = this.getShuttleCountByLev(currentLev);//获取穿梭车楼层车辆数量
|
// if (!wrkMasts1.isEmpty() && shuttleCount <= 1) {
|
// //存在其他任务且可用小车数量小于等于1，跳过这辆车
|
// continue;
|
// }
|
|
//ABS(目标楼层 - 当前楼层) 得到差距，取最小差值
|
int currentValue = Math.abs(lev - currentLev);
|
if (diffShuttles.get(currentValue) != null) {
|
diffShuttles.put(currentValue + 1, shuttleThread);
|
} else {
|
diffShuttles.put(currentValue, shuttleThread);
|
}
|
}
|
|
//尝试调度跨楼层小车
|
for (Map.Entry<Integer, ShuttleThread> entry : diffShuttles.entrySet()) {
|
ShuttleThread shuttleThread = entry.getValue();
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//尝试调度小车
|
boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
|
if (result) {
|
return true;//调度成功
|
}
|
}
|
}
|
}
|
|
News.info("{}目标库位没有搜索到可用穿梭车", locNo);
|
return false;
|
}
|
|
/**
|
* 调度车辆
|
*/
|
public boolean searchDispatchShuttleNoLift(Integer wrkNo, String sourceLocNo, String locNo, String flag) {
|
ArrayList<ShuttleThread> diffLev = new ArrayList<>();//不同楼层的穿梭车
|
int lev1 = 0;
|
boolean tongLev = false;
|
for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
|
//获取四向穿梭车线程
|
ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
if (shuttleProtocol == null || shuttleProtocol.getShuttleNo() == null) {
|
continue;
|
}
|
|
if (checkChargeWrk(shuttle.getId())) {
|
continue;//存在充电任务，过滤小车
|
}
|
|
if (!shuttleThread.isIdle()) {
|
continue;//小车忙碌中
|
}
|
|
BasShuttle basShuttle = basShuttleService.selectOne(new EntityWrapper<BasShuttle>().eq("shuttle_no", shuttle.getId()));
|
if (basShuttle != null) {
|
if (basShuttle.getStatus() == 0) {
|
continue;//小车被禁用
|
}
|
}
|
diffLev.add(shuttleThread);
|
if (lev1 != 0) {
|
if (lev1 == Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
|
tongLev = true;
|
}
|
} else {
|
lev1 = Utils.getLev(shuttleProtocol.getCurrentLocNo());
|
}
|
}
|
|
//寻找离任务楼层最近的穿梭车(不考虑跨楼层小车移动距离)
|
if (!diffLev.isEmpty()) {
|
Map<Integer, ShuttleThread> diffShuttles = new TreeMap<>();//自然排序小车Map
|
//获取任务
|
WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkNo);
|
if (wrkMast1 != null) {
|
int lev = 1;
|
boolean b = wrkMast1.getIoType() < 100;
|
if (b) {
|
//ruku
|
if (wrkMast1.getStaNo() == 1015) {
|
lev = 1;
|
} else {
|
lev = 5;
|
}
|
} else {
|
lev = Utils.getLev(wrkMast1.getSourceLocNo());//目标楼层
|
}
|
|
|
//检测目标楼层车数量是否小于允许的最大数量
|
boolean checkDispatchMaxNum = checkDispatchMaxNum(lev);
|
if (!checkDispatchMaxNum) {
|
News.info("{}任务，{}层，已经达到当前楼层调度车辆最大值", wrkMast1.getWrkNo(), lev);
|
return false;
|
}
|
|
for (ShuttleThread shuttleThread : diffLev) {
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
//当前穿梭车库位号
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
int currentLev = Utils.getLev(currentLocNo);
|
if (wrkMast1.getIoType() == 101 && currentLocNo.equals(locNo)) {
|
//车辆当前位置已经是目标库位，调度该车
|
//给工作档绑定小车号
|
diffShuttles.put(-1, shuttleThread);
|
} else {
|
if (tongLev) {
|
//当前穿梭车线程到目标地点距离
|
List<NavigateNode> currentShuttlePath = navigateUtils.calc(currentLocNo, locNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleProtocol.getShuttleNo(), Utils.getLev(currentLocNo)), null);//搜索空闲穿梭车，使用正常通道地图
|
if (currentShuttlePath == null) {
|
continue;
|
}
|
Integer currentAllDistance = navigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
|
diffShuttles.put(currentAllDistance, shuttleThread);
|
} else {
|
//ABS(目标楼层 - 当前楼层) 得到差距，取最小差值
|
int currentValue = Math.abs(lev - currentLev);
|
if (diffShuttles.get(currentValue) != null) {
|
diffShuttles.put(currentValue + 1, shuttleThread);
|
} else {
|
diffShuttles.put(currentValue, shuttleThread);
|
}
|
}
|
}
|
}
|
|
//尝试调度跨楼层小车
|
for (Map.Entry<Integer, ShuttleThread> entry : diffShuttles.entrySet()) {
|
ShuttleThread shuttleThread = entry.getValue();
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
Integer shuttleNo = shuttleProtocol.getShuttleNo();
|
//尝试调度小车
|
boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
|
if (result) {
|
return true;//调度成功
|
}
|
}
|
}
|
}
|
|
News.info("{}目标库位没有搜索到可用穿梭车", locNo);
|
return false;
|
}
|
|
|
/**
|
* 小车迁移任务生成
|
*/
|
@Transactional
|
public boolean shuttleMoveGenerate(Integer wrkNo, String locNo, Integer shuttleNo) {
|
return shuttleMoveGenerate(wrkNo, null, locNo, shuttleNo, null, false);
|
}
|
|
/**
|
* 小车迁移任务生成
|
*/
|
@Transactional
|
public boolean shuttleMoveGenerate(Integer wrkNo, String sourceLocNo, String locNo, Integer shuttleNo, String flag, boolean disableCheck) {
|
Date now = new Date();
|
//获取四向穿梭车线程
|
ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
|
if (shuttleThread == null) {
|
News.info("{}号小车，线程不存在", shuttleNo);
|
return false;
|
}
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
if (shuttleProtocol == null) {
|
News.info("{}号小车，线程不存在", shuttleNo);
|
return false;
|
}
|
|
//小车处于空闲状态
|
if (!shuttleThread.isIdle()) {
|
News.info("{}号小车，忙碌中", shuttleNo);
|
return false;
|
}
|
|
//判断穿梭车是否存在未完成的小车移库任务
|
WrkMast hasMoveWorking = wrkMastService.selectShuttleHasMoveWorking(shuttleNo);
|
if (hasMoveWorking != null && !disableCheck) {//小车存在移库任务，等待执行完成后再生成新的任务
|
News.info("{}号小车，存在移动任务，等待执行完成后再生成新的任务", shuttleNo);
|
return false;
|
}
|
WrkMast mainWrkMast = null;
|
//获取主工作档信息
|
if (wrkNo != null) {
|
mainWrkMast = wrkMastService.selectByWorkNo(wrkNo);
|
}
|
|
//判断是否有其他任务正在使用穿梭车
|
WrkMast wrkMast2 = wrkMastService.selectShuttleWorking2(shuttleNo, wrkNo, mainWrkMast != null ? mainWrkMast.getMainWrkNo() : null);
|
if (wrkMast2 != null && !disableCheck) {//小车存在其他工作档任务，等待执行完成后再生成新的任务
|
if (mainWrkMast == null) {
|
News.info("{}号小车，存在其他工作档任务，等待执行完成再生成新的任务", shuttleNo);
|
return false;
|
} else {
|
if (mainWrkMast.getShuttleNo() != null && !mainWrkMast.getShuttleNo().equals(shuttleNo)) {
|
News.info("{}号小车，存在其他工作档任务，等待执行完成再生成新的任务", shuttleNo);
|
return false;
|
}
|
}
|
}
|
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
if (sourceLocNo != null) {
|
currentLocNo = sourceLocNo;
|
}
|
|
// 获取工作号
|
int workNo = commonService.getWorkNo(WrkIoType.SHUTTLE_MOVE.id);
|
// 保存工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setMk(flag);
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(now);
|
wrkMast.setWrkSts(WrkStsType.NEW_MOVE.sts); // 工作状态：301.生成迁移任务
|
wrkMast.setIoType(WrkIoType.SHUTTLE_MOVE.id); // 入出库状态： 200.小车迁移
|
wrkMast.setIoPri(800D);
|
wrkMast.setShuttleNo(shuttleNo);//穿梭车号
|
wrkMast.setSourceLocNo(currentLocNo); // 源库位
|
wrkMast.setLocNo(locNo); // 目标库位
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiTime(now);
|
|
if ("TRANSPORT_LIFT".equalsIgnoreCase(flag) || "TRANSPORT_DEVP".equalsIgnoreCase(flag)) {
|
wrkMast.setMainWrkNo(wrkNo);
|
}
|
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
News.error("小车迁移 --- 保存工作档失败！ 穿梭车号：" + shuttleNo);
|
throw new CoolException("保存工作档失败");
|
}
|
|
//给工作档绑定小车号
|
if (mainWrkMast != null) {
|
mainWrkMast.setShuttleNo(shuttleNo);
|
wrkMastService.updateById(mainWrkMast);
|
}
|
|
return true;
|
}
|
|
/**
|
* 小车集合
|
*/
|
public List<ShuttleGatherResult> shuttleGather(ShuttleGatherParam param) {
|
Wrapper<BasShuttle> wrapper = new EntityWrapper<BasShuttle>().eq("status", 1);
|
if (param != null) {
|
if (!param.getShuttleNos().isEmpty()) {
|
wrapper.in("shuttle_no", param.getShuttleNos());
|
}
|
}
|
|
List<BasShuttle> basShuttles = basShuttleService.selectList(wrapper);
|
List<ShuttleGatherResult> list = new ArrayList<>();
|
for (BasShuttle basShuttle : basShuttles) {
|
String idleLoc = basShuttle.getIdleLoc();
|
if (Cools.isEmpty(idleLoc)) {
|
continue;
|
}
|
|
boolean result = shuttleMoveGenerate(null, idleLoc, basShuttle.getShuttleNo());
|
|
ShuttleGatherResult gatherResult = new ShuttleGatherResult();
|
gatherResult.setShuttleNo(basShuttle.getShuttleNo());
|
gatherResult.setIdleLoc(idleLoc);
|
gatherResult.setResult(result);
|
list.add(gatherResult);
|
}
|
return list;
|
}
|
|
/**
|
* 检测目标楼层车数量是否小于允许的最大数量
|
* true: 小于最大数量 false: 大于或等于最大数量
|
*/
|
public boolean checkDispatchMaxNum(Integer lev) {
|
EntityWrapper<Config> wrapper = new EntityWrapper<>();
|
wrapper.eq("code", "dispatchShuttleMaxNum");
|
Config config = configService.selectOne(wrapper);
|
if (config == null) {
|
return false;
|
}
|
|
int levCount = 0;//目标楼层车辆数量
|
for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
|
//获取四向穿梭车线程
|
ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
if (shuttleProtocol == null || shuttleProtocol.getShuttleNo() == null) {
|
continue;
|
}
|
|
//小车有充电任务
|
if (shuttleThread.isCharging()) {
|
continue;
|
}
|
|
//小车故障跳过
|
if (shuttleThread.isFault()) {
|
continue;
|
}
|
|
String currentLocNo = shuttleProtocol.getCurrentLocNo();
|
if (currentLocNo == null) {
|
continue;
|
}
|
int currentLev = Utils.getLev(currentLocNo);
|
|
if (lev == currentLev) {
|
if (shuttleThread.isCharging()) {
|
continue;
|
}
|
levCount++;//目标楼层有车，数量增加
|
}
|
}
|
|
//搜索是否存在前往目标楼层的小车移动工作档
|
for (WrkMast wrkMast : wrkMastService.selectShuttleMoveWrk()) {
|
if (wrkMast.getSourceLocNo() == null || wrkMast.getLocNo() == null) {
|
continue;
|
}
|
|
int sourceLev = Utils.getLev(wrkMast.getSourceLocNo());//工作档源楼层
|
int targetLev = Utils.getLev(wrkMast.getLocNo());//工作档目标楼层
|
if (sourceLev == lev) {
|
continue;//工作档楼层和目标楼层相同，跳过
|
}
|
|
if (targetLev == lev) {
|
levCount++;//工作档目标楼层和实际楼层相同，数量增加
|
continue;
|
}
|
}
|
|
|
return levCount < Integer.parseInt(config.getValue());
|
}
|
|
|
/**
|
* 检测是否穿梭车是否有充电任务
|
*/
|
public boolean checkChargeWrk(int shuttleNo) {
|
//判断是否有充电任务正在使用穿梭车
|
WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttleNo);
|
if (wrkMast != null) {
|
return true;//有充电任务
|
}
|
return false;//无充电任务
|
}
|
|
/**
|
* 获取楼层可用小车数量
|
*/
|
public int getShuttleCountByLev(int lev) {
|
int count = 0;
|
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 || shuttleProtocol.getShuttleNo() == null) {
|
continue;
|
}
|
|
if (checkChargeWrk(slave.getId())) {
|
continue;//存在充电任务，过滤小车
|
}
|
|
if (!shuttleThread.isIdle()) {
|
continue;
|
}
|
|
if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) == lev) {
|
//同一楼层可用小车
|
count++;
|
continue;
|
}
|
}
|
return count;
|
}
|
|
}
|
