lhq/FT546-WCS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

小车下发任务，生成最短路径修改

Browse Source
This commit is contained in:
liuhanqing
2025-11-27 15:42:57 +08:00
parent 548f55109a
commit 2fbf07d555
2 changed files with 5 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

570
ruoyi-admin/src/main/java/com/ruoyi/bas/srgvmap/service/impl/AgvPathProcessor.java
View File

@@ -1,570 +0,0 @@
package com.ruoyi.bas.srgvmap.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import com.ruoyi.bas.srgvmap.domain.WcsSrgvMap;
import com.ruoyi.bas.srgvmap.service.IWcsSrgvMapService;
import com.ruoyi.bas.srgvmap.service.RoadCacheService;
import com.ruoyi.device.srgv.domain.DeviceSrgv;
import com.ruoyi.device.srgv.service.IDeviceSrgvService;
import com.ruoyi.queue.srgv.domain.WcsSrgvQueue;
import com.ruoyi.queue.srgv.service.IWcsSrgvQueueService;
import com.ruoyi.schedule.plcRead.srgv.PlcSrgvRead;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.stream.Collectors;
@Component
public class AgvPathProcessor {
@Autowired
private IDeviceSrgvService plcService;
@Autowired
private IWcsSrgvQueueService wcsSagvQueueMapper;
@Autowired
private RoadCacheService roadCacheService;
public void processNoSites(int[][] roadCache, int floor, List<String> noSite) {
}
public void processAgvPathInfo(Map<String, WcsSrgvMap> maps,Integer agvId) {
List<WcsSrgvQueue> wcsSrgvQueues = wcsSagvQueueMapper.selectWcsSrgvQueueList(new WcsSrgvQueue());
if (CollUtil.isNotEmpty(wcsSrgvQueues)) {
//筛选其他小车队列
wcsSrgvQueues = wcsSrgvQueues.stream().filter(x -> x.getAgvId().equals(Convert.toStr(agvId))).collect(Collectors.toList());
//获取其他小车占用点位列表
HashSet<String> siteList = new HashSet<>();
for (WcsSrgvQueue wcsSrgvQueue : wcsSrgvQueues) {
String[] split = wcsSrgvQueue.getPathInfo().split(",");
siteList.addAll(Arrays.asList(split));
}
//设置其他小车占用点位
for (String site : siteList) {
if (maps.containsKey(site)){
maps.get(site).setValue(0);
}
}
}
}
/**
* 更新AGV路径映射，只保留当前站点及以后的路径
*/
private void updateAgvPathMap(Map<String, String> agvPathMap, List<SRGVPlc> srgvPlcs) {
for (SRGVPlc plc : srgvPlcs) {
com.ruoyi.plc.sagv.SRGVData agvData = plc.getAgvData();
if (agvData != null && agvData.getAgvId() != null) {
String agvId = agvData.getAgvId();
String currSite = agvData.getCurrSite();
// 如果这个agvId在agvPathMap中存在，且currSite不为空
if (agvPathMap.containsKey(agvId) && currSite != null) {
String pathInfo = agvPathMap.get(agvId);
// 处理路径信息，只保留当前站点及以后的路径
if (pathInfo != null && !pathInfo.isEmpty()) {
String[] pathArray = pathInfo.split(",");
StringBuilder newPathBuilder = new StringBuilder();
boolean foundCurrentSite = false;
for (String site : pathArray) {
if (site.trim().equals(currSite.trim())) {
foundCurrentSite = true;
}
if (foundCurrentSite) {
if (newPathBuilder.length() > 0) {
newPathBuilder.append(",");
}
newPathBuilder.append(site);
}
}
// 如果找到了当前站点，更新路径信息
if (foundCurrentSite) {
agvPathMap.put(agvId, newPathBuilder.toString());
}
}
}
}
}
}
public void processOnlineAgvSites(Map<String, WcsSrgvMap> maps) {
}
public void processOfflineAgvSites(Map<String, WcsSrgvMap> maps) {
}
/**
* 处理AGV路径信息和地图障碍
*//*
public void processAgvPathInfo(int floor, List<WcsSrgvMap> slots, IWcsSrgvMapService service) {
WcsSagvQueue wcsSagvQueue = new WcsSagvQueue();
wcsSagvQueue.setTheFloor(floor + "");
List<WcsSagvQueue> wcsSagvQueues = wcsSagvQueueMapper.selectWcsSagvQueueList(wcsSagvQueue);
if (wcsSagvQueues.isEmpty()) {
return;
}
// 转为map,key为agvId ，value为pathInfo
Map<String, String> agvPathMap = new HashMap<>();
for (WcsSagvQueue queue : wcsSagvQueues) {
if (queue.getAgvId() != null && queue.getPathInfo() != null) {
agvPathMap.put(queue.getAgvId(), queue.getPathInfo());
}
}
if (agvPathMap.isEmpty()) {
return;
}
// 获取Sagv位置
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 处理路径信息，只保留当前站点及以后的路径
updateAgvPathMap(agvPathMap, srgvPlcs);
// 将路径拆分成站点，更新对应slot的value值
updateSlotsWithValueFromPath(slots, agvPathMap);
}
*//**
* 更新AGV路径映射，只保留当前站点及以后的路径
*//*
private void updateAgvPathMap(Map<String, String> agvPathMap, List<SRGVPlc> srgvPlcs) {
for (SRGVPlc plc : srgvPlcs) {
com.ruoyi.plc.sagv.SRGVData agvData = plc.getAgvData();
if (agvData != null && agvData.getAgvId() != null) {
String agvId = agvData.getAgvId();
String currSite = agvData.getCurrSite();
// 如果这个agvId在agvPathMap中存在，且currSite不为空
if (agvPathMap.containsKey(agvId) && currSite != null) {
String pathInfo = agvPathMap.get(agvId);
// 处理路径信息，只保留当前站点及以后的路径
if (pathInfo != null && !pathInfo.isEmpty()) {
String[] pathArray = pathInfo.split(",");
StringBuilder newPathBuilder = new StringBuilder();
boolean foundCurrentSite = false;
for (String site : pathArray) {
if (site.trim().equals(currSite.trim())) {
foundCurrentSite = true;
}
if (foundCurrentSite) {
if (newPathBuilder.length() > 0) {
newPathBuilder.append(",");
}
newPathBuilder.append(site);
}
}
// 如果找到了当前站点，更新路径信息
if (foundCurrentSite) {
agvPathMap.put(agvId, newPathBuilder.toString());
}
}
}
}
}
}
*//**
* 根据路径信息更新slots的value值
*//*
private void updateSlotsWithValueFromPath(List<WcsSrgvMap> slots, Map<String, String> agvPathMap) {
// 创建一个站点到AGV ID的映射
Map<String, String> siteToAgvMap = new HashMap<>();
for (Map.Entry<String, String> entry : agvPathMap.entrySet()) {
String agvId = entry.getKey();
String pathInfo = entry.getValue();
if (pathInfo != null && !pathInfo.isEmpty()) {
String[] sites = pathInfo.split(",");
for (String site : sites) {
String trimmedSite = site.trim();
if (!trimmedSite.isEmpty()) {
siteToAgvMap.put(trimmedSite, agvId);
}
}
}
}
// 遍历slots，更新匹配的元素
for (WcsSrgvMap slot : slots) {
String siteId = slot.getSiteId();
if (siteId != null && siteToAgvMap.containsKey(siteId)) {
String agvId = siteToAgvMap.get(siteId);
updateSlotValue(slot, agvId);
}
}
}
*//**
* 处理在线AGV站点
*//*
public void processOnlineAgvSites(List<WcsSrgvMap> slots) {
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 创建siteId到slot的映射以提高查找性能
Map<String, WcsSrgvMap> siteSlotMap = new HashMap<>();
for (WcsSrgvMap slot : slots) {
if (slot.getSiteId() != null) {
siteSlotMap.put(slot.getSiteId(), slot);
}
}
for (SRGVPlc plc : srgvPlcs) {
com.ruoyi.plc.sagv.SRGVData agvData = plc.getAgvData();
if (agvData != null) {
String currSite = agvData.getCurrSite();
String agvId = agvData.getAgvId();
if (currSite != null && agvId != null && siteSlotMap.containsKey(currSite)) {
WcsSrgvMap slot = siteSlotMap.get(currSite);
updateSlotValue2(slot, agvId);
}
}
}
}
*//**
* 处理离线AGV站点
*//*
public void processOfflineAgvSites(int floor, List<WcsSrgvMap> slots) {
WcsAgv wcsAgv = new WcsAgv();
wcsAgv.setDefault01(floor + "");
List<WcsAgv> wcsAgvs = wcsAgvMapper.selectWcsAgvList(wcsAgv);
// 创建siteId到slot的映射以提高查找性能
Map<String, WcsSrgvMap> siteSlotMap = new HashMap<>();
for (WcsSrgvMap slot : slots) {
if (slot.getSiteId() != null) {
siteSlotMap.put(slot.getSiteId(), slot);
}
}
// 处理离线站点
for (WcsAgv agv : wcsAgvs) {
String default02 = agv.getDefault02(); // 离线站点
String agvId = String.valueOf(wcsAgv.getAgvId());
if (default02 != null && agvId != null && siteSlotMap.containsKey(default02)) {
WcsSrgvMap slot = siteSlotMap.get(default02);
updateSlotValue2(slot, agvId);
}
}
}
*//**
* 更新slot的value值为(agvId + 100)
*//*
private void updateSlotValue(WcsSrgvMap slot, String agvId) {
try {
int agvIdNum = Integer.parseInt(agvId);
slot.setValue(agvIdNum + 100);
} catch (NumberFormatException e) {
// 如果agvId不是数字，设置默认值100
// slot.setValue(100);
}
}
private void updateSlotValue2(WcsSrgvMap slot, String agvId) {
try {
int agvIdNum = Integer.parseInt(agvId);
slot.setValue(agvIdNum + 200);
} catch (NumberFormatException e) {
// 如果agvId不是数字，设置默认值100
// slot.setValue(100);
}
}
*//*
*
* 剔除二维数组地图中不允许的站点
*
* *//*
public void processAgvPathInfo(int[][] ints, int floor) {
WcsSagvQueue wcsSagvQueue = new WcsSagvQueue();
wcsSagvQueue.setTheFloor(floor + "");
List<WcsSagvQueue> wcsSagvQueues = wcsSagvQueueMapper.selectWcsSagvQueueList(wcsSagvQueue);
if (wcsSagvQueues.isEmpty()) {
return;
}
// 转为map,key为agvId ，value为pathInfo
Map<String, String> agvPathMap = new HashMap<>();
for (WcsSagvQueue queue : wcsSagvQueues) {
if (queue.getAgvId() != null && queue.getPathInfo() != null) {
agvPathMap.put(queue.getAgvId(), queue.getPathInfo());
}
}
if (agvPathMap.isEmpty()) {
return;
}
// 获取Sagv位置
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 处理路径信息，只保留当前站点及以后的路径
updateAgvPathMap(agvPathMap, srgvPlcs);
// 将路径拆分成站点，更新对应slot的value值
updateSlotsWithValueFromPath2(ints,agvPathMap,floor);
}
public void processAgvPathInfo(int[][] ints, int floor,String agvId) {
WcsSagvQueue wcsSagvQueue = new WcsSagvQueue();
wcsSagvQueue.setTheFloor(floor + "");
List<WcsSagvQueue> wcsSagvQueueList = wcsSagvQueueMapper.selectWcsSagvQueueList(wcsSagvQueue);
List<WcsSagvQueue> wcsSagvQueues = wcsSagvQueueList.stream().filter(queue -> !Objects.equals(queue.getAgvId(), agvId)).collect(Collectors.toList());
if (wcsSagvQueues.isEmpty()) {
return;
}
// 转为map,key为agvId ，value为pathInfo
Map<String, String> agvPathMap = new HashMap<>();
for (WcsSagvQueue queue : wcsSagvQueues) {
if (queue.getAgvId() != null && queue.getPathInfo() != null) {
agvPathMap.put(queue.getAgvId(), queue.getPathInfo());
}
}
if (agvPathMap.isEmpty()) {
return;
}
// 获取Sagv位置
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 处理路径信息，只保留当前站点及以后的路径
updateAgvPathMap(agvPathMap, srgvPlcs);
// 将路径拆分成站点，更新对应slot的value值
updateSlotsWithValueFromPath2(ints,agvPathMap,floor);
}
private void updateSlotsWithValueFromPath2(int[][] arrMap, Map<String, String> agvPathMap, int floor) {
// 在循环前获取一次站点坐标映射
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
for (Map.Entry<String, String> entry : agvPathMap.entrySet()) {
String agvId = entry.getKey();
String pathInfo = entry.getValue();
if (pathInfo != null && !pathInfo.isEmpty()) {
String[] sites = pathInfo.split(",");
for (String site : sites) {
String trimmedSite = site.trim();
if (!trimmedSite.isEmpty()) {
int[] siteArr = arrByRoadSite.get(trimmedSite); // 格式{1，2，3}代表排列层
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
arrMap[siteArr[0]][siteArr[1]] = 0; // 建对应坐标更新为0，代表障碍物
}
}
}
}
}
}
*//**
* 处理在线AGV站点
*//*
public void processOnlineAgvSites(int[][] arrMap, int floor) {
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 过滤出同层的当前站点，并处理空值情况
List<String> collect = srgvPlcs.stream()
.filter(plc -> plc.getAgvData() != null && plc.getAgvData().getCurrSite() != null)
.filter(plc -> floor == plc.getLayer())
.map(plc -> plc.getAgvData().getCurrSite())
.collect(Collectors.toList());
if (!collect.isEmpty()) {
// 在循环前获取一次站点坐标映射
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
for (String site : collect) {
String trimmedSite = site.trim();
if (!trimmedSite.isEmpty()) {
int[] siteArr = arrByRoadSite.get(trimmedSite); // 格式{1,2,3}代表排列层
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
arrMap[siteArr[0]][siteArr[1]] = 0; // 对应坐标更新为0，代表障碍物
}
}
}
}
}
public void processOnlineAgvSites(int[][] arrMap, int floor,String selfSite) {
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 过滤出同层的当前站点，并处理空值情况
List<String> collect = srgvPlcs.stream()
.filter(plc -> plc.getAgvData() != null && plc.getAgvData().getCurrSite() != null)
.filter(plc -> floor == plc.getLayer())
.filter(p ->!Objects.equals(p.getAgvData().getCurrSite(),selfSite))
.map(plc -> plc.getAgvData().getCurrSite())
.collect(Collectors.toList());
if (!collect.isEmpty()) {
// 在循环前获取一次站点坐标映射
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
for (String site : collect) {
String trimmedSite = site.trim();
if (!trimmedSite.isEmpty()) {
int[] siteArr = arrByRoadSite.get(trimmedSite); // 格式{1,2,3}代表排列层
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
arrMap[siteArr[0]][siteArr[1]] = 0; // 对应坐标更新为0，代表障碍物
}
}
}
}
}
*//*
*
* 处理在线AGV站点,不包含自己
* *//*
public void processOnlineAgvSitesNoSelf(int[][] arrMap, Integer floor, String srcSite) {
List<SRGVPlc> srgvPlcs = plcService.listSRGVPlcData();
// 过滤出同层的当前站点，并处理空值情况
List<String> collect = srgvPlcs.stream()
.filter(plc -> plc.getAgvData() != null && plc.getAgvData().getCurrSite() != null)
.filter(plc -> floor == plc.getLayer())
.map(plc -> plc.getAgvData().getCurrSite())
.collect(Collectors.toList());
if (!collect.isEmpty()) {
// 在循环前获取一次站点坐标映射
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
for (String site : collect) {
String trimmedSite = site.trim();
if (!trimmedSite.isEmpty() && !Objects.equals(srcSite, trimmedSite)) {
int[] siteArr = arrByRoadSite.get(trimmedSite); // 格式{1,2,3}代表排列层
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
arrMap[siteArr[0]][siteArr[1]] = 0; // 对应坐标更新为0，代表障碍物
}
}
}
}
}
*//**
* 处理离线AGV站点
*//*
public void processOfflineAgvSites(int[][] arrMap, int floor) {
WcsAgv wcsAgv = new WcsAgv();
wcsAgv.setDefault01(floor + "");
List<WcsAgv> wcsAgvs = wcsAgvMapper.selectWcsAgvList(wcsAgv);
// 根据站点获取二维数组坐标
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
// 处理离线站点
for (WcsAgv agv : wcsAgvs) {
// 添加空值检查
if (agv != null && agv.getDefault02() != null && agv.getAgvId() != null) {
String default02 = agv.getDefault02(); // 离线站点
String agvId = String.valueOf(wcsAgv.getAgvId());
String trimmedSite = default02.trim();
if (!trimmedSite.isEmpty()) {
int[] siteArr = arrByRoadSite.get(trimmedSite);
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
arrMap[siteArr[0]][siteArr[1]] = 0; // 对应坐标更新为0，代表障碍物
}
}
}
}
}
*//*
* 离线站点占用目标的也排除
* *//*
public void processOfflineAgvSites(int[][] arrMap, int floor,List<String> tarSite) {
WcsAgv wcsAgv = new WcsAgv();
wcsAgv.setDefault01(floor + "");
List<WcsAgv> wcsAgvs = wcsAgvMapper.selectWcsAgvList(wcsAgv);
// 根据站点获取二维数组坐标
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
// 处理离线站点
for (WcsAgv agv : wcsAgvs) {
// 添加空值检查
if (agv != null && agv.getDefault02() != null && agv.getAgvId() != null) {
String default02 = agv.getDefault02(); // 离线站点
String agvId = String.valueOf(wcsAgv.getAgvId());
String trimmedSite = default02.trim();
if (!trimmedSite.isEmpty()) {
int[] siteArr = arrByRoadSite.get(trimmedSite);
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
arrMap[siteArr[0]][siteArr[1]] = 0; // 对应坐标更新为0，代表障碍物
}
//排除目标
tarSite.remove(trimmedSite);
}
}
}
}
public void processNoSites(int[][] roadCache, int floor,List<String> sites) {
// 根据站点获取二维数组坐标
Map<String, int[]> arrByRoadSite = roadCacheService.getArrByRoadSite(floor);
for (String site : sites) {
if (!site.isEmpty()) {
int[] siteArr = arrByRoadSite.get(site);
// 添加空值检查
if (siteArr != null && siteArr.length >= 2) {
roadCache[siteArr[0]][siteArr[1]] = 0; // 对应坐标更新为0，代表障碍物
}
}
}
}*/
}

10
ruoyi-admin/src/main/java/com/ruoyi/schedule/plcRead/srgv/roadUtil/PathFinder.java
View File

@@ -528,7 +528,7 @@ public class PathFinder {
} }
// 计算拐点 // 计算拐点
List<int[]> inflectionPoints = extractInflectionPoints2(path, grid); List<int[]> inflectionPoints = extractInflectionPoints2(path);
return new PathInfo(path, inflectionPoints.size()); return new PathInfo(path, inflectionPoints.size());
} }
)); ));
@@ -585,7 +585,7 @@ public class PathFinder {
} }
// 计算拐点 // 计算拐点
List<int[]> inflectionPoints = extractInflectionPoints2(path, grid); List<int[]> inflectionPoints = extractInflectionPoints2(path);
return new PathInfo(path, inflectionPoints.size()); return new PathInfo(path, inflectionPoints.size());
} }
)); ));
@@ -647,7 +647,7 @@ public class PathFinder {
} }
// 计算拐点 // 计算拐点
List<int[]> inflectionPoints = extractInflectionPoints2(path, grid); List<int[]> inflectionPoints = extractInflectionPoints2(path);
return new PathInfo(path, inflectionPoints.size()); return new PathInfo(path, inflectionPoints.size());
} }
)); ));
@@ -719,7 +719,7 @@ public class PathFinder {
} }
// 计算拐点 // 计算拐点
List<int[]> inflectionPoints = extractInflectionPoints2(path, tempGrid); List<int[]> inflectionPoints = extractInflectionPoints2(path);
return new PathInfo(path, inflectionPoints.size()); return new PathInfo(path, inflectionPoints.size());
}, },
(existing, replacement) -> existing // 合并函数：如果键冲突，保留现有的值 (existing, replacement) -> existing // 合并函数：如果键冲突，保留现有的值
@@ -780,7 +780,7 @@ public class PathFinder {
} }
// 计算拐点 // 计算拐点
List<int[]> inflectionPoints = extractInflectionPoints2(path, tempGrid); List<int[]> inflectionPoints = extractInflectionPoints2(path);
return new PathInfo(path, inflectionPoints.size()); return new PathInfo(path, inflectionPoints.size());
} }
)); ));