From daa2cec25875276f3462e09d102f9d2fd52a96e1 Mon Sep 17 00:00:00 2001
From: L <L@132>
Date: 星期三, 18 三月 2026 16:03:43 +0800
Subject: [PATCH] *
---
src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java | 921 +++++++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 762 insertions(+), 159 deletions(-)
diff --git a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
index 1a6f127..fd7d991 100644
--- a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
+++ b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
@@ -1,15 +1,24 @@
package com.zy.asrs.service.impl;
import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
+import com.core.common.R;
+import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.BasCircularShuttleService;
import com.zy.asrs.service.BasDevpPositionService;
-import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.WrkMastService;
+import com.zy.asrs.task.core.ReturnT;
+import com.zy.asrs.task.escalationParam.RgvTaskReportingParam;
+import com.zy.asrs.utils.PostMesDataUtils;
import com.zy.asrs.utils.SortTheExecutionOfTheCarUtil;
+import com.zy.asrs.utils.TaskDispatchPriorityUtil;
import com.zy.asrs.utils.TimeCalculatorUtils;
+import com.zy.common.CodeRes;
+import com.zy.common.service.CommonService;
+import com.zy.common.utils.HttpHandler;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
@@ -19,6 +28,7 @@
import com.zy.core.model.protocol.RgvProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.RgvThread;
+import com.zy.system.entity.license.LicenseVerify;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -29,7 +39,7 @@
/**
* 绔嬩綋浠撳簱WCS绯荤粺涓绘祦绋嬩笟鍔�
- * Created by vincent on 2020/8/6
+ * Created by IX on 2024/10/01
*/
@Slf4j
@Service("mainService")
@@ -39,8 +49,6 @@
@Autowired
private SlaveProperties slaveProperties;
@Autowired
- private BasDevpService basDevpService;
- @Autowired
private BasRgvServiceImpl basRgvService;
@Autowired
private BasDevpPositionService basDevpPositionService;
@@ -48,38 +56,76 @@
private BasCircularShuttleService basCircularShuttleService;
@Autowired
private WrkMastService wrkMastService;
+ @Autowired
+ private CommonService commonService;
+ @Value("${constant-parameters.taskRunPerimeter}")
+ private Long taskRunPerimeter;
@Value("${constant-parameters.perimeter}")
private Long perimeter;
+ @Value("${constant-parameters.proportion}")
+ private Long proportion;
+ @Value("${constant-parameters.acceleration}")
+ private Long acceleration;
+ @Value("${constant-parameters.rgvCount}")
+ private Long rgvCount;
+ @Value("${constant-parameters.rgvDate}")
+ private Double rgvDate;
+ @Value("${wms.url}")
+ private String wmsUrl;
+ @Value("${wms.reportOutPath}")
+ private String wmsOutPath;
+ @Value("${wms.reportSwitch}")
+ private boolean reportSwitch;
+ @Value("${wms.reportSwitchAuto}")
+ private boolean reportSwitchAuto;
+ @Value("${constant-parameters.priority.distance-threshold:10000}")
+ private Long priorityDistanceThreshold;
+ @Value("${constant-parameters.priority.weight.time:0.4}")
+ private Double priorityTimeWeight;
+ @Value("${constant-parameters.priority.weight.distance:0.4}")
+ private Double priorityDistanceWeight;
+ @Value("${constant-parameters.priority.weight.region:0.2}")
+ private Double priorityRegionWeight;
+ @Value("${constant-parameters.priority.region-values:}")
+ private String regionPriorityValues;
+ private volatile String cachedRegionPriorityRaw = "";
+ private volatile Map<Integer, Double> cachedRegionPriorityMap = new HashMap<>();
+
+ /*
+ * 楠岃瘉璁稿彲璇佹槸鍚︽湁鏁�
+ * */
+ public synchronized boolean licenseVerify() {
+ try{
+// if (true) {
+// return true;
+// }
+ return new LicenseVerify().verify();
+ } catch (Exception e){
+ log.info("璁稿彲璇侀獙璇佸け璐ワ紒锛佸紓甯革細{}",e.getMessage());
+ }
+ return false;
+ }
+
/**
* 绔欑偣浠诲姟妫�娴� 鏇存柊灏忚溅浣嶇疆淇℃伅
*/
- public synchronized void updateStePositionNearby() {
- try{
- List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 1L));
- if (wrkMasts.isEmpty()){
- return;
- }
- List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("plc_position",true));
- if (basDevpPositions.isEmpty()){
+ public synchronized int[][] getStePositionNearby(Integer siteNo) {
+ try {
+ List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("plc_position", true));
+ if (basDevpPositions.isEmpty()) {
log.error("鑾峰彇鎵�鏈夌珯鐐逛俊鎭紓甯�");
- return;
- }
- List<Integer> siteList = SortTheExecutionOfTheCarUtil.WrkMastExtractSites(wrkMasts);
- List<Integer> devpList = SortTheExecutionOfTheCarUtil.BasDevpPositionExtractSites(basDevpPositions);
- Integer siteNo = SortTheExecutionOfTheCarUtil.ObtainDenseAreasFirstPlace(siteList, devpList);
- if (siteNo == null){
- log.error("灏辫繎瀵嗛泦鍘熷垯鑾峰彇绔欑偣澶辫触");
- return;
+ return null;
}
Long sitePosition = 0L;
- for (BasDevpPosition basDevpPosition : basDevpPositions){
- if (basDevpPosition.getDevNo().equals(siteNo)){
+ for (BasDevpPosition basDevpPosition : basDevpPositions) {
+ if (basDevpPosition.getDevNo().equals(siteNo)) {
sitePosition = basDevpPosition.getPlcPosition();
+ break;
}
}
List<List<Long>> rgvPositionList = new ArrayList<>();
- for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
+ for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
if (rgvProtocol == null) {
@@ -90,78 +136,75 @@
rgvPosition.add(rgvProtocol.getRgvPos());
rgvPositionList.add(rgvPosition);
}
- Integer rgvNo = SortTheExecutionOfTheCarUtil.LatelyAndGreaterThan(rgvPositionList, sitePosition,perimeter);
- if (rgvNo == -1){
- log.info("鏇存柊灏忚溅鎺掑簭淇℃伅寮傚父={}",rgvNo);
- return;
+ Integer rgvNo = SortTheExecutionOfTheCarUtil.LatelyAndGreaterThan(rgvPositionList, sitePosition, perimeter);
+ if (rgvNo == -1) {
+ log.info("鏇存柊灏忚溅鎺掑簭淇℃伅寮傚父={}", rgvNo);
+ return null;
}
List<BasCircularShuttle> basCircularShuttleList = basCircularShuttleService.selectList(new EntityWrapper<BasCircularShuttle>().orderBy("rgv_id", true));
- if (basCircularShuttleList.get(0).getRgvNo().equals(rgvNo)){
- return;
- }
-
int[][] ints = new int[basCircularShuttleList.size()][2];
- for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
- ints[basCircularShuttle.getRgvNo()-1] = new int[]{basCircularShuttle.getRgvNo(),basCircularShuttle.getRgvId()};
+ for (BasCircularShuttle basCircularShuttle : basCircularShuttleList) {
+ ints[basCircularShuttle.getRgvNo() - 1] = new int[]{basCircularShuttle.getRgvNo(), basCircularShuttle.getRgvId()};
}
- String[] oldList = new String[ints.length];
- for (int[] rgv : ints){
- oldList[rgv[0]-1] = Arrays.toString(rgv);
+ if (basCircularShuttleList.get(0).getRgvNo().equals(rgvNo)) {
+ return ints;
}
+// String[] oldList = new String[ints.length];
+// for (int[] rgv : ints){
+// oldList[rgv[0]-1] = Arrays.toString(rgv);
+// }
int[][] rgvList = SortTheExecutionOfTheCarUtil.ReorderSteId(ints, rgvNo);
- String[] newList = new String[rgvList.length];
- for (int[] rgv : rgvList){
- newList[rgv[0]-1] = Arrays.toString(rgv);
- }
+ return rgvList;
- log.info("鏇存柊灏忚溅鎺掑簭淇℃伅锛氬師濮嬪皬杞﹀彿rgvNo={},灏忚溅閲嶆柊鎺掑簭淇℃伅={},灏忚溅鍘熷鎺掑簭淇℃伅={}",rgvNo,Arrays.toString(newList),Arrays.toString(oldList));
- for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
- int[] rgv = rgvList[basCircularShuttle.getRgvNo() - 1];
- basCircularShuttle.setRgvId(rgv[1]);
- basCircularShuttleService.updateById(basCircularShuttle);
- }
} catch (Exception e) {
- log.error("鑷姩鏇存柊灏忚溅鎺掑簭淇℃伅澶辫触锛屽紓甯革細"+e);
+ log.error("鑷姩鏇存柊灏忚溅鎺掑簭淇℃伅澶辫触锛屽紓甯革細" + e);
}
+ return null;
+
}
+
/**
* 绔欑偣浠诲姟妫�娴� 鏇存柊灏忚溅浣嶇疆淇℃伅
*/
public synchronized void updateStePosition() {
- try{
+ try {
boolean sign = false;
Integer rgvNo = 0;
List<BasCircularShuttle> basCircularShuttleList = basCircularShuttleService.selectList(new EntityWrapper<BasCircularShuttle>().orderBy("rgv_id", true));
- for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
+ for (BasCircularShuttle basCircularShuttle : basCircularShuttleList) {
+ if (basCircularShuttle.getStatus() != 0){
+ sign = true;
+ continue;
+ }
RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
if (rgvProtocol == null) {
sign = true;
- } else if (rgvProtocol.modeType != RgvModeType.AUTO || (rgvProtocol.getStatusType() != RgvStatusType.IDLE && rgvProtocol.getStatusType() != RgvStatusType.ROAM) ){
+ } else if (rgvProtocol.modeType != RgvModeType.AUTO || (rgvProtocol.getStatusType() != RgvStatusType.IDLE && rgvProtocol.getStatusType() != RgvStatusType.ROAM && rgvProtocol.getStatusType() != RgvStatusType.WALK)) {
sign = true;
} else {
rgvNo = basCircularShuttle.getRgvNo();
break;
}
}
- if (sign && rgvNo!=0){
+ if (sign && rgvNo != 0) {
int[][] ints = new int[basCircularShuttleList.size()][2];
- for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
- ints[basCircularShuttle.getRgvNo()-1] = new int[]{basCircularShuttle.getRgvNo(),basCircularShuttle.getRgvId()};
+ for (BasCircularShuttle basCircularShuttle : basCircularShuttleList) {
+ ints[basCircularShuttle.getRgvNo() - 1] = new int[]{basCircularShuttle.getRgvNo(), basCircularShuttle.getRgvId()};
}
- String[] oldList = new String[ints.length];
- for (int[] rgv : ints){
- oldList[rgv[0]-1] = Arrays.toString(rgv);
- }
+// String[] oldList = new String[ints.length];
+// for (int[] rgv : ints){
+// oldList[rgv[0]-1] = Arrays.toString(rgv);
+// }
int[][] rgvList = SortTheExecutionOfTheCarUtil.ReorderSteId(ints, rgvNo);
- String[] newList = new String[rgvList.length];
- for (int[] rgv : rgvList){
- newList[rgv[0]-1] = Arrays.toString(rgv);
- }
+// String[] newList = new String[rgvList.length];
+// for (int[] rgv : rgvList){
+// newList[rgv[0]-1] = Arrays.toString(rgv);
+// }
- log.info("鏇存柊灏忚溅鎺掑簭淇℃伅锛氬師濮嬪皬杞﹀彿rgvNo={},灏忚溅閲嶆柊鎺掑簭淇℃伅={},灏忚溅鍘熷鎺掑簭淇℃伅={}",rgvNo,Arrays.toString(newList),Arrays.toString(oldList));
- for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
+// log.info("鏇存柊灏忚溅鎺掑簭淇℃伅锛氬師濮嬪皬杞﹀彿rgvNo={},灏忚溅閲嶆柊鎺掑簭淇℃伅={},灏忚溅鍘熷鎺掑簭淇℃伅={}",rgvNo,Arrays.toString(newList),Arrays.toString(oldList));
+ for (BasCircularShuttle basCircularShuttle : basCircularShuttleList) {
int[] rgv = rgvList[basCircularShuttle.getRgvNo() - 1];
basCircularShuttle.setRgvId(rgv[1]);
basCircularShuttleService.updateById(basCircularShuttle);
@@ -169,52 +212,379 @@
}
} catch (Exception e) {
- log.error("鑷姩鏇存柊灏忚溅鎺掑簭淇℃伅澶辫触锛屽紓甯革細"+e);
+ log.error("鑷姩鏇存柊灏忚溅鎺掑簭淇℃伅澶辫触锛屽紓甯革細" + e);
}
}
+
/**
* 绔欑偣浠诲姟妫�娴� 涓嬪彂灏忚溅鍙栨斁浠诲姟
*/
public synchronized void DevpTaskNoRun() {
- try{
- List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 1L).orderBy("modi_time",true));
- if (wrkMasts.isEmpty()){
- return;
- }
- long differenceInSeconds = TimeCalculatorUtils.differenceInSeconds(wrkMasts.get(0).getModiTime(), new Date());
- if (differenceInSeconds<=5){
- return;
- }
-
- BasCircularShuttle basCircularShuttle = basCircularShuttleService.selectOne(new EntityWrapper<BasCircularShuttle>().eq("rgv_id", 1));
- RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
- RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
- if (rgvProtocol == null) {
- return;
- }
- List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("plc_position",true));
- Integer devNo = SortTheExecutionOfTheCarUtil.LatelyAndLessThan(basDevpPositions, rgvProtocol.getRgvPos(),perimeter);
- BasDevpPosition[] basDevpPositionsList = SortTheExecutionOfTheCarUtil.devpNoSort(basDevpPositions, devNo);
- BasDevpPosition[] basDevpPositionsListUN = SortTheExecutionOfTheCarUtil.devpNoSortUN(basDevpPositionsList);
- List<List<WrkMast>> wrkMastLists = getWrkMastLists(basDevpPositionsListUN);
- //涓嬪彂浠诲姟
- taskDown(wrkMastLists);
- } catch (Exception e){
- log.error("鑷姩涓嬪彂灏忚溅鍙栨斁浠诲姟澶辫触锛屽紓甯革細"+e);
+ try {
+ dispatchTaskByFlow();
+ } catch (Exception e) {
+ log.error("鑷姩涓嬪彂灏忚溅浠诲姟澶辫触锛屽紓甯革細{}", e.getMessage(), e);
}
+ }
+
+ /**
+ * 娴佺▼鍥剧増: 浠诲姟姹犳寫浠诲姟骞朵笅鍙慠GV
+ * 鏃堕棿/璺濈/鍖哄煙鎸夋潈閲嶈绠楁渶缁堜紭鍏堢骇锛屽啀鎵ц涓嬪彂銆�
+ */
+ private void dispatchTaskByFlow() {
+ Date now = new Date();
+ List<WrkMast> taskPool = wrkMastService.selectList(
+ new EntityWrapper<WrkMast>().eq("wrk_sts", 1L).orderBy("modi_time", true)
+ );
+ if (taskPool.isEmpty()) {
+ return;
+ }
+
+ Date firstTaskTime = taskPool.get(0).getAppeTime() == null ? taskPool.get(0).getModiTime() : taskPool.get(0).getAppeTime();
+ if (firstTaskTime == null) {
+ return;
+ }
+ long oldestWaitMs = TimeCalculatorUtils.differenceInMilliseconds(firstTaskTime, now);
+ if (oldestWaitMs <= 1000) {
+ return;
+ }
+
+ List<BasDevpPosition> sitePositions = basDevpPositionService.selectList(
+ new EntityWrapper<BasDevpPosition>().orderBy("plc_position", true)
+ );
+ if (sitePositions == null || sitePositions.isEmpty()) {
+ return;
+ }
+
+ Map<Integer, BasDevpPosition> siteMap = new HashMap<>();
+ for (BasDevpPosition site : sitePositions) {
+ siteMap.put(site.getDevNo(), site);
+ }
+
+ List<RgvRuntimeState> availableRgvs = loadAvailableRgvs();
+ if (availableRgvs.isEmpty()) {
+ return;
+ }
+ Map<Integer, RgvRuntimeState> rgvStateMap = new HashMap<>();
+ List<TaskDispatchPriorityUtil.RgvSnapshot> snapshots = new ArrayList<>();
+ for (RgvRuntimeState rgv : availableRgvs) {
+ if (rgv.protocol == null || rgv.protocol.getRgvPos() == null) {
+ continue;
+ }
+ rgvStateMap.put(rgv.shuttle.getRgvNo(), rgv);
+ snapshots.add(new TaskDispatchPriorityUtil.RgvSnapshot(rgv.shuttle.getRgvNo(), rgv.protocol.getRgvPos()));
+ }
+ if (snapshots.isEmpty()) {
+ return;
+ }
+
+ double[] weights = resolveWeights(taskPool.size(), snapshots.size());
+ List<TaskDispatchPriorityUtil.DispatchPlan> plans = TaskDispatchPriorityUtil.rankDispatchPlans(
+ taskPool,
+ siteMap,
+ snapshots,
+ parseRegionPriorityMap(),
+ now,
+ Math.max(1L, priorityDistanceThreshold == null ? 10000L : priorityDistanceThreshold),
+ Math.max(1L, perimeter == null ? 1L : perimeter),
+ weights[0],
+ weights[1],
+ weights[2]
+ );
+ if (plans.isEmpty()) {
+ return;
+ }
+
+ TaskDispatchPriorityUtil.DispatchPlan topPlan = plans.get(0);
+ WrkMast task = topPlan.getTask();
+ if (task == null || task.getSourceStaNo() == null) {
+ return;
+ }
+ BasDevpPosition source = siteMap.get(task.getSourceStaNo());
+ if (source == null) {
+ return;
+ }
+ RgvRuntimeState chosenRgv = rgvStateMap.get(topPlan.getRgvNo());
+ if (chosenRgv == null) {
+ return;
+ }
+
+ log.info("浠诲姟浼樺厛绾ц绠�: wrkNo={} rgvNo={} final={} (time={} distance={} region={}) distance={} inRange={}",
+ task.getWrkNo(),
+ topPlan.getRgvNo(),
+ topPlan.getFinalPriority(),
+ topPlan.getTimePriority(),
+ topPlan.getDistancePriority(),
+ topPlan.getRegionPriority(),
+ topPlan.getDistance(),
+ topPlan.isInRange());
+
+ if (topPlan.isInRange() && canFetchFromRoam(chosenRgv.protocol, source.getPlcPosition())) {
+ if (issueFetchTask(task, chosenRgv)) {
+ updateStePosition();
+ }
+ return;
+ }
+ issueRoamTask(chosenRgv, source.getPlcPosition());
+ }
+
+ private List<RgvRuntimeState> loadAvailableRgvs() {
+ List<RgvRuntimeState> result = new ArrayList<>();
+ List<BasCircularShuttle> shuttles = basCircularShuttleService.selectList(
+ new EntityWrapper<BasCircularShuttle>().orderBy("rgv_id", true)
+ );
+ if (shuttles == null || shuttles.isEmpty()) {
+ return result;
+ }
+
+ for (BasCircularShuttle shuttle : shuttles) {
+ try {
+ if (shuttle.getStatus() != 0) {
+ continue;
+ }
+ RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, shuttle.getRgvNo());
+ if (rgvThread == null) {
+ continue;
+ }
+ RgvProtocol protocol = rgvThread.getRgvProtocol();
+ if (!isAvailableRgv(protocol)) {
+ continue;
+ }
+ if (isRgvRunningTask(shuttle.getRgvNo())) {
+ continue;
+ }
+ result.add(new RgvRuntimeState(shuttle, protocol));
+ } catch (Exception ignore) {
+ }
+ }
+ return result;
+ }
+
+ private boolean isAvailableRgv(RgvProtocol protocol) {
+ return protocol != null
+ && protocol.getModeType() == RgvModeType.AUTO
+ && (protocol.getStatusType() == RgvStatusType.IDLE || protocol.getStatusType() == RgvStatusType.ROAM)
+ && protocol.getTaskNo1() == 0
+ && protocol.getRgvPosInt() != 0
+ && protocol.getAlarm() == 0;
+ }
+
+ private boolean isRgvRunningTask(Integer rgvNo) {
+ List<WrkMast> running = wrkMastService.selectList(
+ new EntityWrapper<WrkMast>().eq("rgv_no", rgvNo).eq("wrk_sts", 2L)
+ );
+ return running != null && !running.isEmpty();
+ }
+
+ private boolean canFetchFromRoam(RgvProtocol protocol, long sourcePos) {
+ if (protocol.getStatusType() != RgvStatusType.ROAM) {
+ return true;
+ }
+ if (protocol.getInstantaneousSpeed() == null || acceleration == null || acceleration == 0) {
+ return true;
+ }
+ double finalVelocity = 0.0;
+ double distance = (Math.pow(finalVelocity, 2) - Math.pow(protocol.getInstantaneousSpeed() / 60, 2)) / (2 * acceleration);
+ double threshold = distance * proportion + (protocol.getInstantaneousSpeed() / 60) * proportion * rgvDate;
+ double sourceDistance = SortTheExecutionOfTheCarUtil.LatelyAndLessThan(sourcePos, protocol.getRgvPos(), perimeter);
+ return !(threshold > sourceDistance);
+ }
+
+ private boolean issueFetchTask(WrkMast task, RgvRuntimeState rgv) {
+ RgvCommand command = new RgvCommand();
+ command.setRgvNo(rgv.shuttle.getRgvNo());
+ command.setAckFinish1((short) 0);
+ command.setTaskNo1(task.getWrkNo().shortValue());
+ command.setTaskMode1(RgvTaskModeType.FETCH_PUT);
+ command.setSourceStaNo1(task.getSourceStaNo().shortValue());
+ command.setDestinationStaNo1(task.getStaNo().shortValue());
+ command.setCommand((short) 1);
+ command.setRgvSome(rgv.shuttle.getRgvSome() == 1 ? (short) 1 : (short) 0);
+
+ if (!MessageQueue.offer(SlaveType.Rgv, rgv.shuttle.getRgvNo(), new Task(2, command))) {
+ task.setLogErrTime(new Date());
+ task.setLogErrMemo("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={" + rgv.shuttle.getRgvNo() + "}===>璺宠繃");
+ wrkMastService.updateById(task);
+ log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgv.shuttle.getRgvNo(), JSON.toJSON(command));
+ return false;
+ }
+
+ Date now = new Date();
+ task.setWrkSts(2L);
+ task.setRgvNo(rgv.shuttle.getRgvNo());
+ task.setAppeTime(now);
+ task.setCrnStrTime(now);
+ wrkMastService.updateById(task);
+ log.info("RGV鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}锛屼换鍔″彿={}锛宻ource={}锛宼arget={}",
+ rgv.shuttle.getRgvNo(), task.getWrkNo(), task.getSourceStaNo(), task.getStaNo());
+ return true;
+ }
+
+ private void issueRoamTask(RgvRuntimeState rgv, long sourcePos) {
+ if (rgv == null || rgv.protocol == null) {
+ return;
+ }
+ if (rgv.protocol.getStatusType() != RgvStatusType.IDLE) {
+ return;
+ }
+ long destination = getRoamDestination(sourcePos);
+ if (!MessageQueue.offer(SlaveType.Rgv, rgv.shuttle.getRgvNo(), new Task(5, destination))) {
+ log.error("RGV婕父浠诲姟涓嬪彂澶辫触锛孯GV鍙�={}锛岀洰鐨勫湴={}", rgv.shuttle.getRgvNo(), destination);
+ return;
+ }
+ log.info("RGV婕父浠诲姟涓嬪彂鎴愬姛锛孯GV鍙�={}锛岀洰鐨勫湴={}", rgv.shuttle.getRgvNo(), destination);
+ }
+
+ private long getRoamDestination(long sourcePos) {
+ long destination = sourcePos - taskRunPerimeter + 10000;
+ if (destination > perimeter) {
+ return 10000L;
+ }
+ if (destination <= 0) {
+ destination = perimeter + destination;
+ }
+ return destination;
+ }
+
+ private Map<Integer, Double> parseRegionPriorityMap() {
+ String raw = regionPriorityValues == null ? "" : regionPriorityValues.trim();
+ if (raw.equals(cachedRegionPriorityRaw)) {
+ return cachedRegionPriorityMap;
+ }
+ Map<Integer, Double> regionMap = new HashMap<>();
+ if (raw.isEmpty()) {
+ cachedRegionPriorityRaw = raw;
+ cachedRegionPriorityMap = regionMap;
+ return regionMap;
+ }
+ String[] items = raw.split(",");
+ for (String item : items) {
+ if (item == null || item.trim().isEmpty()) {
+ continue;
+ }
+ String[] pair = item.split(":");
+ if (pair.length != 2) {
+ continue;
+ }
+ try {
+ Integer region = Integer.valueOf(pair[0].trim());
+ Double priority = Double.valueOf(pair[1].trim());
+ if (priority > 1D) {
+ priority = 1D;
+ } else if (priority < -1D) {
+ priority = -1D;
+ }
+ regionMap.put(region, priority);
+ } catch (Exception ignore) {
+ }
+ }
+ cachedRegionPriorityRaw = raw;
+ cachedRegionPriorityMap = regionMap;
+ return regionMap;
+ }
+
+ private double[] resolveWeights(int pendingTaskCount, int availableRgvCount) {
+ double timeW = priorityTimeWeight == null ? 0.4D : priorityTimeWeight;
+ double distanceW = priorityDistanceWeight == null ? 0.4D : priorityDistanceWeight;
+ double regionW = priorityRegionWeight == null ? 0.2D : priorityRegionWeight;
+
+ double capacity = Math.max(1D, availableRgvCount * 2D);
+ double loadFactor = Math.min(1D, pendingTaskCount / capacity);
+ if (loadFactor > 0.7D) {
+ timeW = Math.min(0.55D, timeW + 0.10D);
+ distanceW = Math.max(0.10D, distanceW - 0.05D);
+ } else if (loadFactor < 0.4D) {
+ timeW = Math.max(0.25D, timeW - 0.05D);
+ distanceW = Math.min(0.55D, distanceW + 0.05D);
+ }
+
+ double sum = Math.abs(timeW) + Math.abs(distanceW) + Math.abs(regionW);
+ if (sum <= 0D) {
+ return new double[]{0.4D, 0.4D, 0.2D};
+ }
+ return new double[]{timeW / sum, distanceW / sum, regionW / sum};
+ }
+
+ private static class RgvRuntimeState {
+ private final BasCircularShuttle shuttle;
+ private final RgvProtocol protocol;
+
+ private RgvRuntimeState(BasCircularShuttle shuttle, RgvProtocol protocol) {
+ this.shuttle = shuttle;
+ this.protocol = protocol;
+ }
+ }
+
+ //鑾峰彇灏忚溅鍙栨斁浠诲姟鍒楄〃澶辫触
+ public synchronized List<List<List<WrkMast>>> getWrkMastListAll(List<List<Integer>> siteListAll ,BasDevpPosition[] basDevpPositionsListUN) {
+ List<List<List<WrkMast>>> wrkMastListAll = new ArrayList<>();
+ List<Integer> sourceStaNoList = new ArrayList<>();
+
+ for (List<Integer> siteList : siteListAll){
+ List<List<WrkMast>> wrkMastLists = new ArrayList<>();
+ try {
+ List<WrkMast> wrkMastlistA = new ArrayList<>();
+ List<WrkMast> wrkMastlistB = new ArrayList<>();
+ List<WrkMast> wrkMastlistC = new ArrayList<>();
+ List<WrkMast> wrkMastlistD = new ArrayList<>();
+ for (BasDevpPosition basDevpPosition : basDevpPositionsListUN) {
+ List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("sta_no", basDevpPosition.getDevNo()).eq("wrk_sts", 1L).orderBy("modi_time", true));
+ for (WrkMast wrkMast : wrkMastList) {
+ if (!Cools.isEmpty(wrkMast)) {
+ if (siteList.contains(wrkMast.getSourceStaNo())){
+ if (!sourceStaNoList.contains(wrkMast.getSourceStaNo())){
+ List<WrkMast> wrkMastListS = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("source_sta_no", wrkMast.getSourceStaNo()).eq("wrk_sts", 1L).orderBy("modi_time", true));
+ if (wrkMastListS.isEmpty()){
+ continue;
+ }
+ } else {
+ continue;
+ }
+ long differenceInSeconds = TimeCalculatorUtils.differenceInMilliseconds(wrkMast.getModiTime(), new Date());
+
+ if (SortTheExecutionOfTheCarUtil.devpNoSortbj(basDevpPositionsListUN, wrkMast.getSourceStaNo(), wrkMast.getStaNo())) {
+ sourceStaNoList.add(wrkMast.getSourceStaNo());
+ if (differenceInSeconds>600000){
+ wrkMastlistA.add(wrkMast);
+ } else {
+ wrkMastlistC.add(wrkMast);
+ }
+ } else {
+ sourceStaNoList.add(wrkMast.getSourceStaNo());
+ if (differenceInSeconds>600000){
+ wrkMastlistB.add(wrkMast);
+ } else {
+ wrkMastlistD.add(wrkMast);
+ }
+ }
+ }
+ }
+ }
+ }
+ wrkMastLists.add(wrkMastlistA);
+ wrkMastLists.add(wrkMastlistB);
+ wrkMastLists.add(wrkMastlistC);
+ wrkMastLists.add(wrkMastlistD);
+// return wrkMastLists;
+ wrkMastListAll.add(wrkMastLists);
+ } catch (Exception e) {
+ log.error("鑾峰彇灏忚溅鍙栨斁浠诲姟鍒楄〃澶辫触锛屽紓甯革細" + e);
+ }
+ }
+ return wrkMastListAll;
}
//鑾峰彇灏忚溅鍙栨斁浠诲姟鍒楄〃澶辫触
public synchronized List<List<WrkMast>> getWrkMastLists(BasDevpPosition[] basDevpPositionsListUN) {
List<List<WrkMast>> wrkMastLists = new ArrayList<>();
- try{
+ try {
List<WrkMast> wrkMastlistA = new ArrayList<>();
List<WrkMast> wrkMastlistB = new ArrayList<>();
- for (BasDevpPosition basDevpPosition : basDevpPositionsListUN){
- List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("sta_no", basDevpPosition.getDevNo()).eq("wrk_sts", 1L).orderBy("modi_time",true));
- for (WrkMast wrkMast:wrkMastList){
- if (!Cools.isEmpty(wrkMast)){
- if (SortTheExecutionOfTheCarUtil.devpNoSortbj(basDevpPositionsListUN,wrkMast.getSourceStaNo(),wrkMast.getStaNo())){
+ for (BasDevpPosition basDevpPosition : basDevpPositionsListUN) {
+ List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("sta_no", basDevpPosition.getDevNo()).eq("wrk_sts", 1L).orderBy("modi_time", true));
+ for (WrkMast wrkMast : wrkMastList) {
+ if (!Cools.isEmpty(wrkMast)) {
+ if (SortTheExecutionOfTheCarUtil.devpNoSortbj(basDevpPositionsListUN, wrkMast.getSourceStaNo(), wrkMast.getStaNo())) {
wrkMastlistA.add(wrkMast);
} else {
wrkMastlistB.add(wrkMast);
@@ -225,64 +595,191 @@
wrkMastLists.add(wrkMastlistA);
wrkMastLists.add(wrkMastlistB);
return wrkMastLists;
- } catch (Exception e){
- log.error("鑾峰彇灏忚溅鍙栨斁浠诲姟鍒楄〃澶辫触锛屽紓甯革細"+e);
+ } catch (Exception e) {
+ log.error("鑾峰彇灏忚溅鍙栨斁浠诲姟鍒楄〃澶辫触锛屽紓甯革細" + e);
return wrkMastLists;
}
}
- public synchronized void taskDown(List<List<WrkMast>> wrkMastLists) {
- long rgvId = 0;
- runRgv:
- for (List<WrkMast> wrkMastList : wrkMastLists){
- for (WrkMast wrkMast: wrkMastList){
- log.error("瀛樺湪浠诲姟锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvId, JSON.toJSON(wrkMast));
+ public synchronized void taskDown(List<List<List<WrkMast>>> wrkMastListAll) {
+ List<Integer> rgvNoM = new ArrayList<>();
+ List<Integer> rgvNoR = new ArrayList<>();
+ int wrkMastRunCount = 0;
+ long devperimeter = 0L;
+ try{
+ for (List<List<WrkMast>> wrkMastLists : wrkMastListAll) {
+ List<Integer> rgvNoRN = new ArrayList<>();
+ runRgv:
+ for (List<WrkMast> wrkMastList : wrkMastLists) {
+ for (WrkMast wrkMast : wrkMastList) {
- rgvId++;
- BasCircularShuttle basCircularShuttle = basCircularShuttleService.selectOne(new EntityWrapper<BasCircularShuttle>().eq("rgv_id", 1L));
- RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
- RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
- if (rgvProtocol != null
- && rgvProtocol.modeType == RgvModeType.AUTO
- && (rgvProtocol.getStatusType() == RgvStatusType.IDLE || rgvProtocol.getStatusType() == RgvStatusType.ROAM)
- && rgvProtocol.getTaskNo1()==0
- && rgvProtocol.getAlarm() == 0){
- RgvCommand rgvCommand = new RgvCommand();
- rgvCommand.setRgvNo(rgvProtocol.getRgvNo());
- rgvCommand.setAckFinish1((short) 0); // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
- rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue());
- rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 宸ヤ綅1浠诲姟妯″紡: 鍙栨斁璐�
- rgvCommand.setSourceStaNo1(wrkMast.getSourceStaNo().shortValue()); //宸ヤ綅1璧风偣
- rgvCommand.setDestinationStaNo1(wrkMast.getStaNo().shortValue()); //宸ヤ綅1鐩爣绔欑偣
- rgvCommand.setCommand((short) 1); //宸ヤ綅1浠诲姟纭
- if (!MessageQueue.offer(SlaveType.Rgv, rgvProtocol.getRgvNo(), new Task(2, rgvCommand))) {
- //
- log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvId, JSON.toJSON(rgvCommand));
- break runRgv;
- }
- log.error("RGV鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvId, JSON.toJSON(rgvCommand));
+ int[][] stePositionNearby = getStePositionNearby(wrkMast.getSourceStaNo());
+ if (stePositionNearby==null){
+ break runRgv;
+ }
- wrkMast.setWrkSts(2L);
- wrkMast.setRgvNo(rgvProtocol.getRgvNo());
- wrkMast.setAppeTime(new Date());
- try{
- wrkMastService.updateById(wrkMast);
- continue ;
- }catch (Exception e){
- log.error("鏇存柊灏忚溅浠诲姟澶辫触,浠诲姟鍙凤細"+wrkMast.getWrkNo());
+ int[] rgvListRun = new int[stePositionNearby.length];
+ for (int[] rgvNo:stePositionNearby){
+ rgvListRun[rgvNo[0]-1] = rgvNo[1];
+ }
+
+ for (int rgvNo : rgvListRun){
+ if (rgvNoRN.contains(rgvNo)){
+ continue;
+ }
+
+ BasCircularShuttle basCircularShuttle = basCircularShuttleService.selectOne(new EntityWrapper<BasCircularShuttle>().eq("rgv_no", rgvNo));
+ if (basCircularShuttle.getStatus() != 0){
+ continue ;
+ }
+ long rgvId = basCircularShuttle.getRgvId();
+
+ RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
+ RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
+ if (rgvProtocol == null) {
+ continue;
+ }
+
+ List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("rgv_no", rgvProtocol.getRgvNo()).eq("wrk_sts", 2L));
+ if (!wrkMasts.isEmpty()) {
+ continue;
+ }
+ if (rgvProtocol != null
+ && rgvProtocol.modeType == RgvModeType.AUTO
+ && (rgvProtocol.getStatusType() == RgvStatusType.IDLE || rgvProtocol.getStatusType() == RgvStatusType.ROAM)
+ && rgvProtocol.getTaskNo1() == 0
+ && rgvProtocol.getRgvPosInt() != 0
+ && rgvProtocol.getAlarm() == 0) {
+ BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("dev_no", wrkMast.getSourceStaNo()));
+ if (basDevpPosition.getPlcPosition()>rgvProtocol.getRgvPos()){
+ if (basDevpPosition.getPlcPosition()-rgvProtocol.getRgvPos()>taskRunPerimeter){
+ if (!rgvNoM.contains(rgvProtocol.getRgvNo())){
+ rgvNoM.add(rgvProtocol.getRgvNo());
+ rgvNoRN.add(rgvProtocol.getRgvNo());
+ if (wrkMastRunCount == 0){
+ devperimeter = basDevpPosition.getPlcPosition()-taskRunPerimeter+10000>perimeter? 10000:basDevpPosition.getPlcPosition()-taskRunPerimeter+10000;
+ }
+ wrkMastRunCount++;
+ break;
+ }
+ continue ;
+ }
+ } else {
+ if (rgvProtocol.getRgvPos()+ perimeter -basDevpPosition.getPlcPosition()>taskRunPerimeter){
+ if (!rgvNoM.contains(rgvProtocol.getRgvNo())){
+ rgvNoM.add(rgvProtocol.getRgvNo());
+ rgvNoRN.add(rgvProtocol.getRgvNo());
+ if (wrkMastRunCount == 0){
+ devperimeter = basDevpPosition.getPlcPosition()-taskRunPerimeter+10000>perimeter? 10000:basDevpPosition.getPlcPosition()-taskRunPerimeter+10000;
+ }
+ wrkMastRunCount++;
+ break;
+ }
+ continue ;
+ }
+ }
+
+ if (rgvProtocol.getStatusType() == RgvStatusType.ROAM) {
+ double finalVelocity = 0.0; // 鏈�缁堥�熷害 (m/s)
+ double distance = (Math.pow(finalVelocity, 2) - Math.pow(rgvProtocol.instantaneousSpeed / 60, 2)) / (2 * acceleration);
+ if ((distance * proportion + (rgvProtocol.instantaneousSpeed / 60) * proportion * rgvDate) > (SortTheExecutionOfTheCarUtil.LatelyAndLessThan(basDevpPosition.getPlcPosition(), rgvProtocol.getRgvPos(), perimeter) )) {
+// List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("plc_position", true));
+// if (basDevpPositions.isEmpty()) {
+// log.error("鑾峰彇鎵�鏈夌珯鐐逛俊鎭紓甯�,RGV浠诲姟涓嬪彂澶辫触锛岃鑱旂郴绠＄悊鍛橈紒锛侊紒");
+// break runRgv;
+// }
+// List<Integer> devpList = SortTheExecutionOfTheCarUtil.BasDevpPositionExtractSites(basDevpPositions);
+//
+// if (!SortTheExecutionOfTheCarUtil.calculateShortestDistanceDirection(devpList,rgvProtocol.getEndStaM(),wrkMast.getSourceStaNo())){
+ continue;
+// }
+ }
+ }
+
+ rgvNoRN.add(rgvProtocol.getRgvNo());
+ if (!rgvNoR.contains(rgvProtocol.getRgvNo())){
+ rgvNoR.add(rgvProtocol.getRgvNo());
+ } else {
+ continue ;
+ }
+
+ RgvCommand rgvCommand = new RgvCommand();
+ rgvCommand.setRgvNo(rgvProtocol.getRgvNo());
+ rgvCommand.setAckFinish1((short) 0); // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+ rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue());
+ rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 宸ヤ綅1浠诲姟妯″紡: 鍙栨斁璐�
+ rgvCommand.setSourceStaNo1(wrkMast.getSourceStaNo().shortValue()); //宸ヤ綅1璧风偣
+ rgvCommand.setDestinationStaNo1(wrkMast.getStaNo().shortValue()); //宸ヤ綅1鐩爣绔欑偣
+ rgvCommand.setCommand((short) 1); //宸ヤ綅1浠诲姟纭
+ rgvCommand.setRgvSome(basCircularShuttle.getRgvSome()==1 ? (short) 1 : (short) 0);
+ if (!MessageQueue.offer(SlaveType.Rgv, rgvProtocol.getRgvNo(), new Task(2, rgvCommand))) {
+ //
+ log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvId, JSON.toJSON(rgvCommand));
+ wrkMast.setLogErrTime(new Date());
+ wrkMast.setLogErrMemo("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={"+rgvId+"}===>璺宠繃");
+ wrkMastService.updateById(wrkMast);
+ break runRgv;
+ }
+ log.info("RGV鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvId, JSON.toJSON(rgvCommand));
+
+ wrkMast.setWrkSts(2L);
+ wrkMast.setRgvNo(rgvProtocol.getRgvNo());
+ Date now = new Date();
+ wrkMast.setAppeTime(now);
+ wrkMast.setCrnStrTime(now);
+ try {
+ wrkMastService.updateById(wrkMast);
+ break;
+ } catch (Exception e) {
+ log.error("鏇存柊灏忚溅浠诲姟澶辫触,浠诲姟鍙凤細" + wrkMast.getWrkNo());
+ }
+ break runRgv;
+ }
+ }
}
- break runRgv;
- } else {
- break runRgv;
}
}
+
+ } catch (Exception e){
+ log.error("RGV鍙栨斁璐у惎鍔ㄥ懡浠や笅鍙戝け璐ワ紝浠诲姟鏁版嵁===> "+JSON.toJSON(wrkMastListAll));
+ return;
+ }
+ try{
+ for (Integer rgvNo : rgvNoM){
+ if (wrkMastRunCount==0){
+ break;
+ }
+ if (rgvNoR.contains(rgvNo)){
+ continue;
+ }
+ RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvNo);
+ RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
+ if (rgvProtocol == null) {
+ continue;
+ }
+ wrkMastRunCount--;
+ if (rgvProtocol != null
+ && rgvProtocol.modeType == RgvModeType.AUTO
+ && rgvProtocol.getStatusType() == RgvStatusType.IDLE
+ && rgvProtocol.getTaskNo1() == 0
+ && rgvProtocol.getAlarm() == 0) {
+ if (!MessageQueue.offer(SlaveType.Rgv, rgvProtocol.getRgvNo(), new Task(5,devperimeter))) {
+ log.error("RGV婕父鍚姩鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvNo, "婕父鎸囦护锛岀洰鐨勫湴锛�"+devperimeter);
+ break;
+ } else {
+ log.info("RGV婕父鍚姩鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvNo, "婕父鎸囦护锛岀洰鐨勫湴锛�"+devperimeter);
+ }
+ }
+ }
+ } catch (Exception e){
+
}
}
//浠诲姟瀹屾垚
- public synchronized void rgvCompleteWrkMastSta() {
- try{
- for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
+ public synchronized void rgvCompleteWrkMastSta(int[] autoZ) {
+ for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
+ try {
RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
if (rgvProtocol == null) {
@@ -293,50 +790,156 @@
log.error("{}鍙稲GV灏氭湭鍦ㄦ暟鎹簱杩涜缁存姢锛�", rgvSlave.getId());
continue;
}
- if (rgvProtocol.getStatusType() == RgvStatusType.WAITING){
- log.info("{}鍙峰皬杞︾瓑寰厀cs纭锛岀姸鎬亄}锛屽弬鏁皗}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
+ if (rgvProtocol.getStatusType() == RgvStatusType.WAITING || rgvProtocol.getStatusType() == RgvStatusType.WAITING101) {
+ log.info("{}鍙峰皬杞︾瓑寰厀cs纭锛岀姸鎬亄}锛屽弬鏁皗}", rgvProtocol.getRgvNo(), rgvProtocol.getStatusType(), rgvProtocol);
}
// 鍙湁褰揜GV绛夊緟WCS纭銆佽嚜鍔�
if (rgvProtocol.getStatusType() == RgvStatusType.WAITING
&& rgvProtocol.getModeType() == RgvModeType.AUTO
- && rgvProtocol.getTaskNo1()!=0
+ && rgvProtocol.getTaskNo1() != 0
) {
- log.info("{}鍙峰皬杞︾瓑寰厀cs纭锛岀姸鎬亄}锛屽弬鏁皗}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
- WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", rgvProtocol.getTaskNo1().longValue()));
- if (Cools.isEmpty(wrkMast) || !wrkMast.getWrkSts().equals(2L)){
- log.error("鏈煡鍒板皬杞︽墽琛屼换鍔℃垨鑰呮墽琛屼换鍔＄姸鎬佷笉绗﹀悎锛�"+wrkMast);
+// log.info("{}鍙峰皬杞︾瓑寰厀cs纭锛岀姸鎬亄}锛屽弬鏁皗}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
+ WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", rgvProtocol.getTaskNo1().longValue()).eq("rgv_no",rgvProtocol.getRgvNo()));
+ if (Cools.isEmpty(wrkMast) || !wrkMast.getWrkSts().equals(2L)) {
+ log.error("鏈煡鍒板皬杞︽墽琛屼换鍔℃垨鑰呮墽琛屼换鍔＄姸鎬佷笉绗﹀悎锛�" + wrkMast);
continue;
}
boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
- if (!rgvComplete){
- log.error("灏忚溅澶嶄綅澶辫触锛屽皬杞﹀彿{}锛�",rgvProtocol.getRgvNo());
+ if (!rgvComplete) {
+ log.error("灏忚溅澶嶄綅澶辫触锛屽皬杞﹀彿{}锛�", rgvProtocol.getRgvNo());
break;
}
wrkMast.setWrkSts(3L);
- wrkMast.setAppeTime(new Date());
+ Date now = new Date();
+ wrkMast.setAppeTime(now);
+ wrkMast.setCrnEndTime(now);
+ try{
+ try{
+ if (reportSwitch){
+ RgvTaskReportingParam rgvTaskReportingParam = new RgvTaskReportingParam(wrkMast);
+ ReturnT<String> result = new PostMesDataUtils().postMesDataWcs(wmsUrl, wmsOutPath, rgvTaskReportingParam);
+ if (result.getCode()==200){
+ wrkMast.setWrkSts(4L);
+ wrkMast.setAppeTime(now);
+ wrkMastService.updateById(wrkMast);
+ continue;
+ }else {
+ log.error("宸ヤ綔鍙�"+wrkMast.getWrkNo()+"浠诲姟瀹屾垚淇℃伅涓婁紶澶勭悊澶辫触1");
+ }
+ } else {
+ //娴嬭瘯鐢�
+ wrkMast.setWrkSts(4L);
+ wrkMast.setAppeTime(now);
+ wrkMastService.updateById(wrkMast);
+ if (reportSwitchAuto) {
+ WrkMast wrkMast1 = new WrkMast();
+ int workNo = commonService.getWorkNo(0);
+ wrkMast1.setWrkNo((long) workNo);
+ wrkMast1.setSourceStaNo(wrkMast.getSourceNoCs(autoZ));
+ wrkMast1.setStaNo(wrkMast.getStaNoCs(autoZ));
+ wrkMast1.setWrkSts(1L);
+ wrkMast1.setIoType(1);
+ wrkMast1.setModiTime(now);
+ wrkMast1.setAppeTime(now);
+ wrkMast1.setMemo("娴嬭瘯鏁版嵁");
+ wrkMastService.insert(wrkMast1);
+ }
+ continue;
+ }
+ } catch (Exception e){
+ log.error("宸ヤ綔鍙�"+wrkMast.getWrkNo()+"浠诲姟瀹屾垚淇℃伅涓婁紶澶勭悊澶辫触锛屽紓甯镐俊鎭細"+e);
+ }
+ } catch (Exception e){}
wrkMastService.updateById(wrkMast);
+ } else if (rgvProtocol.getStatusType() == RgvStatusType.WAITING101
+ && rgvProtocol.getModeType() == RgvModeType.AUTO
+ && rgvProtocol.getTaskNo1() != 0
+ ){
+ boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
+ if (!rgvComplete) {
+ log.error("灏忚溅澶嶄綅澶辫触锛屽皬杞﹀彿{}锛�", rgvProtocol.getRgvNo());
+ break;
+ }
}
+ } catch (Exception e) {
+ log.error("灏忚溅澶嶄綅绾跨▼鎶ラ敊锛�" + e);
}
- } catch (Exception e){
- log.error("灏忚溅澶嶄綅绾跨▼鎶ラ敊锛�"+e);
+ }
+ }
+ public synchronized void rgvCancelWrkMastSta() {
+ for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
+ try {
+ RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
+ RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
+ if (rgvProtocol == null) {
+ continue;
+ }
+ if (rgvProtocol.getStatusType() == RgvStatusType.CANCEL) {
+ log.info("{}鍙峰皬杞︾瓑寰厀cs鍙栨秷锛岀姸鎬亄}锛屽弬鏁皗}", rgvProtocol.getRgvNo(), rgvProtocol.getStatusType(), rgvProtocol);
+ }
+ // 鍙湁褰揜GV绛夊緟WCS纭銆佽嚜鍔�
+ if (rgvProtocol.getStatusType() == RgvStatusType.CANCEL
+ && rgvProtocol.getModeType() == RgvModeType.AUTO
+ && rgvProtocol.getTaskNo1() != 0
+ ) {
+
+ RgvCommand rgvCommand = new RgvCommand();
+ rgvCommand.setRgvNo(rgvProtocol.getRgvNo());
+ rgvCommand.setAckFinish1((short) 0); // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+ rgvCommand.setTaskNo1(rgvProtocol.getTaskNo1());
+ rgvCommand.setTaskMode1(RgvTaskModeType.CANCEL); // 宸ヤ綅1浠诲姟妯″紡: 鍙栨秷
+ rgvCommand.setSourceStaNo1((short)-1); //宸ヤ綅1璧风偣
+ rgvCommand.setDestinationStaNo1((short)-1); //宸ヤ綅1鐩爣绔欑偣
+// rgvCommand.setCommand((short) 1); //宸ヤ綅1浠诲姟纭
+// rgvCommand.setRgvSome((short) 1);
+ if (!MessageQueue.offer(SlaveType.Rgv, rgvProtocol.getRgvNo(), new Task(4, rgvCommand))) {
+ //
+ log.error("RGV鍙栨秷鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
+// wrkMast.setLogErrTime(new Date());
+// wrkMast.setLogErrMemo("RGV鍙栨秷鍛戒护涓嬪彂澶辫触锛孯GV鍙�={"+rgvProtocol.getRgvNo()+"}===>璺宠繃");
+// wrkMastService.updateById(wrkMast);
+ continue;
+ }
+ log.info("RGV鍙栨秷鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
+
+ WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", rgvCommand.getTaskNo1().longValue()).eq("rgv_no",rgvCommand.getRgvNo()));
+ if (Cools.isEmpty(wrkMast) || !wrkMast.getWrkSts().equals(2L)) {
+ log.error("鏈煡鍒板皬杞︽墽琛屼换鍔℃垨鑰呮墽琛屼换鍔＄姸鎬佷笉绗﹀悎锛�" + wrkMast);
+ continue;
+ }
+
+ Date now = new Date();
+ wrkMast.setWrkSts(1L);
+ wrkMast.setRgvNo(0);
+ wrkMast.setAppeTime(now);
+ wrkMast.setLogErrTime(now);
+
+ wrkMast.setLogErrMemo("RGV鐢宠鍙栨秷浠诲姟锛孯GV鍙�={"+rgvProtocol.getRgvNo()+"}锛屽彇娑堟椂闂达細"+now);
+
+ wrkMastService.updateById(wrkMast);
+
+ }
+ } catch (Exception e) {
+ log.error("灏忚溅鍙栨秷绾跨▼鎶ラ敊锛�" + e);
+ }
}
}
/*
* 灏忚溅澶嶄綅
* */
- public synchronized boolean rgvComplete(Integer rgvId){
- try{
+ public synchronized boolean rgvComplete(Integer rgvNo) {
+ try {
// 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
- if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(3, new RgvCommand()))) {
- log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}",rgvId);
+ if (!MessageQueue.offer(SlaveType.Rgv, rgvNo, new Task(3, new RgvCommand()))) {
+ log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}", rgvNo);
return false;
} else {
- log.info("RGV鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}",rgvId);
+ log.info("RGV鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}", rgvNo);
return true;
}
- }catch (Exception e){
- log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}銆傚紓甯革細"+e,rgvId);
+ } catch (Exception e) {
+ log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}銆傚紓甯革細" + e, rgvNo);
return false;
}
}
--
Gitblit v1.9.1