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

现场接口测试和出入库判断调整

Browse Source
This commit is contained in:
lsymicc
2026-04-28 11:17:09 +08:00
parent 955b94c145
commit 741fe220d8
25 changed files with 604 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ruoyi-admin/src/main/java/com/ruoyi/schedule/plcRead/ssj/PlcSsjRead.java
View File

@@ -109,6 +109,7 @@ public class PlcSsjRead implements Runnable {
ssjDevice.setSszt(ParseUtil.optInt(8, ddsx1));
ssjDevice.setRkqq(ParseUtil.optInt(10, ddsx1));
ssjDevice.setHeight(ParseUtil.optInt(12, ddsx1));
ssjDevice.setTraySize(ParseUtil.optInt(12, ddsx1)); //此处不修改device_ssj表，把托盘尺寸值当作高度使用
ssjDevice.setTrayCode(ParseUtil.optString(14, ddsx1));
ssjDevice.setMode(ParseUtil.optInt(24, ddsx1));//todo 输送机操作模式
ssjDevice.setException(ParseUtil.optInt(28, ddsx1));

2
ruoyi-admin/src/main/java/com/ruoyi/schedule/plcRead/util/ParseUtil.java
View File

@@ -46,7 +46,7 @@ public class ParseUtil {
*/
public static String optString(int start, String data) {
byte[] bytes = SoftBasic.HexStringToBytes(data.substring(start * 2, (start + 7) * 2));
byte[] bytes = SoftBasic.HexStringToBytes(data.substring(start * 2, (start + 10) * 2));
return Tools.bytetostringtool(bytes);
}

108
ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/TaskHandler.java
View File

@@ -1,38 +1,53 @@
package com.ruoyi.schedule.scheduleTask;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.UUID;
import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionReceive;
import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionRequest;
import com.ruoyi.api.service.IApiService;
import com.ruoyi.bas.cargospace.domain.BasCargoSpace;
import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.job.domain.MydoJob;
import com.ruoyi.job.service.IJobCallBackService;
import com.ruoyi.job.service.IMydoJobService;
import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue;
import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.List;
import static com.ruoyi.common.TaskExceptionType.TASK_EXCEPTION_STOCKIN_OCCUPIED;
import static com.ruoyi.common.TaskStatusCode.*;
import static com.ruoyi.common.WmsTaskTypeCode.WMS_TASK_TYPE_EXCEPTION;
@Component
@Slf4j
public class TaskHandler {
@Autowired
private IMydoJobService mydoJobService;
@Autowired
private IJobCallBackService jobCallBackService;
@Autowired
private IBasCargoSpaceService basCargoSpaceService;
@Autowired
private IApiService apiService;
@Autowired
private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService;
/**
* 处理未正常移除的【堆垛机执行完成】或【出库到位】的遗留任务
*/
@Scheduled(fixedDelay = 3000)
// @Scheduled(fixedDelay = 3000)
public void mydoJobHandler() {
//此处 - 堆垛机执行完成【TASK_EP_DDJ_FINISH】和出库到位【TASK_EP_SSJ_STOCKOUT_FINISH】的常量值相同，均可表示任务【已完成】
//用任意一种状态查询所有标记为【已完成】的任务
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().executionPhase(TASK_EP_DDJ_FINISH).build()
new MydoJob().builder().executionPhase(TASK_EP_FINISH).build()
);
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
@@ -51,14 +66,45 @@ public class TaskHandler {
}
// @Scheduled(fixedDelay = 3000)
/**
* 入库异常 - 【放货有货】处理方法
*/
@Scheduled(fixedDelay = 2000)
public void stockinExceptionHandler() {
List<MydoJob> jobs = mydoJobService.selectInOrOutMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PUT).build()
);
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
//上报异常 - 向wms请求重分接口
TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest();
taskExceptionRequest.setTaskClass(job.getInOrOut().substring(0, 1));
taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED));
taskExceptionRequest.setTaskCode(job.getWmsTaskNo());
taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么
taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位");
AjaxResult ajaxResult = apiService.reAssign(taskExceptionRequest);
if (ajaxResult.isSuccess()){
//获取返回的任务号和新分配的货位
TaskExceptionReceive mydoJobReAssign = BeanUtil.toBean(ajaxResult.get("data"), TaskExceptionReceive.class);
MydoJob wmsJob = new MydoJob();
wmsJob.setWmsTaskNo(mydoJobReAssign.getTaskCode());
if (mydoJobService.selectMydoJobList(wmsJob).size() == 0) {
log.warn("【响应异常】该任务不存在，任务号:{}", mydoJobReAssign.getTaskCode());
return;
}
//更新任务参数
job = mydoJobService.selectMydoJobByTaskNo(Long.valueOf(job.getTaskNo()));
job.setCargoSpaceId(mydoJobReAssign.getSiteCode());
job.setExecutionPhase(TASK_EXCEPTION_PUT_REASSIGN);
job.setFaultFlag("2");
mydoJobService.updateMydoJob(job);
}
}
}
@@ -66,8 +112,10 @@ public class TaskHandler {
}
// @Scheduled(fixedDelay = 3000)
/**
* 出库异常 - 【取货无货】处理方法
*/
@Scheduled(fixedDelay = 2000)
public void stockoutExceptionHandler() {
List<MydoJob> jobs = mydoJobService.selectInOrOutMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PICK).build()
@@ -75,12 +123,52 @@ public class TaskHandler {
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
mydoJobService.InvalidMydoJob(Long.valueOf(job.getTaskNo()), Integer.valueOf(job.getRoadwayId()));
//向wms返回异常信息
TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest();
taskExceptionRequest.setTaskClass(job.getInOrOut().substring(0, 1));
taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED));
taskExceptionRequest.setTaskCode(String.valueOf(job.getWmsTaskNo()));
taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么
taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务");
AjaxResult ajaxResult = apiService.reMaterial(taskExceptionRequest);
if (ajaxResult.isSuccess()){
mydoJobService.InvalidMydoJob(Long.valueOf(job.getTaskNo()), Integer.valueOf(job.getRoadwayId()));
//清空/重置【取货无货】的出库异常货位库存信息
basCargoSpaceService.resetCargoSpaceByStockoutException(job.getCargoSpaceId());
}
//清空/重置【取货无货】的出库异常货位库存信息
basCargoSpaceService.resetCargoSpaceByStockoutException(job.getCargoSpaceId());
}
}
}
/**
* 入库重分完成 - 堆垛机重新下发
*/
@Scheduled(fixedDelay = 2000)
public void sendTaskForStacker(){
List<MydoJob> jobs = mydoJobService.selectInOrOutMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PUT_REASSIGN).build()
);
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
//获取重分的货位重新向堆垛机下发任务
BasCargoSpace basCargoSpace = basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(job.getCargoSpaceId());
DdjDeviceExecutionQueue ddjDeviceExecutionQueue =
ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(Long.valueOf(job.getTaskNo()), Integer.valueOf(job.getRoadwayId()));
ddjDeviceExecutionQueue.setMbph(basCargoSpace.getThePlatoon());
ddjDeviceExecutionQueue.setMblh(basCargoSpace.getTheColumn());
ddjDeviceExecutionQueue.setMbch(basCargoSpace.getTheFloor());
ddjDeviceExecutionQueue.setDdjxf("0");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
}
}
}

182
ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread.java
View File

@@ -32,6 +32,7 @@ import java.util.List;
import static com.ruoyi.common.TaskExceptionType.TASK_EXCEPTION_STOCKIN_OCCUPIED;
import static com.ruoyi.common.TaskStatusCode.*;
import static com.ruoyi.common.WmsTaskTypeCode.WMS_TASK_TYPE_EXCEPTION;
@Slf4j
@@ -103,16 +104,19 @@ public class DdjThread implements Runnable {
以防存在漏处理，没处理的情况发生
*/
//非【联机自动】状态
if (ddj.getCzfs() != 5) return;
// 检查当前堆垛机参数 - 是否有执行中的作业
// 1.联机自动【5】 2.设备状态【0】 3.执行阶段【0】【5】（无执行中的任务）
if (ddj.getCzfs() == 5 && ddj.getSbzt() == 0 && (ddj.getJdbz() == 5 || ddj.getJdbz() == 0)) {
if (ddj.getSbzt() == 0 && (ddj.getJdbz() == 5 || ddj.getJdbz() == 0)) {
Long rwh = ddj.getRwh();
//完成作业
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId());
//满足上述条件，表示该任务已完成-执行任务回传
//满足上述条件(【有实时任务】且【存在堆垛机执行队列】)，表示该任务已完成-执行任务回传
if (mydoJob != null && ddjDeviceExecutionQueue != null) {
//标记为堆垛机执行完成
mydoJob.setExecutionPhase(TASK_EP_DDJ_FINISH);
@@ -126,7 +130,7 @@ public class DdjThread implements Runnable {
//-------------------------------------- 【2 更新执行阶段】 --------------------------------------
// 1.联机自动【5】 2.设备状态 - 运行中【1】 3.执行阶段【2】
if (ddj.getCzfs() == 5 && ddj.getSbzt() == 1 && ddj.getJdbz() == 2) {
if (ddj.getSbzt() == 1 && ddj.getJdbz() == 2) {
//根据堆垛机上任务号，修改任务执行阶段
Long rwh = ddj.getRwh();
@@ -141,110 +145,121 @@ public class DdjThread implements Runnable {
}
/* -------------------------------------- 【3 放货有货，重新分配货位】-------------------------------------- */
// ddj.setCzfs(5);
// ddj.setSbzt(1052);
// ddj.setYxxf(1);
// ddj.setJdbz(4);
// ddj.setRwh(85015L);
// 1.联机自动【5】 2.设备状态-放货有货【1052】 3.执行阶段【0】【5】（无执行中的任务）
if (ddj.getCzfs() == 5 && ddj.getSbzt() == 1052 && ddj.getJdbz() < 5 && ddj.getYxxf() == 1) {
if (ddj.getSbzt() == 1052 && ddj.getJdbz() < 5 && ddj.getYxxf() == 1) {
// 判断堆垛机上任务是否已重分，若未重分，则调用接口，请求重分货位
Long rwh = ddj.getRwh();
//查村正在执行中的【任务号】获取堆垛机队列
//查询正在执行中的【任务号】获取堆垛机队列
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId());
//更新异常类型【FaultFlag】-1
if ("0".equals(mydoJob.getFaultFlag()) && "1".equals(ddjDeviceExecutionQueue.getSpare1())) {
mydoJob.setStatus("1");
//把执行阶段标记为【入库放货有货】的异常
mydoJob.setExecutionPhase(TASK_EXCEPTION_PUT);
mydoJobService.updateMydoJob(mydoJob);
//上报异常 - 向wms请求重分接口
TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest();
taskExceptionRequest.setTaskClass(mydoJob.getInOrOut());
taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED));
taskExceptionRequest.setTaskCode(mydoJob.getWmsTaskNo());
taskExceptionRequest.setTaskTypeCode("");//todo 不知道填什么
taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位");
AjaxResult ajaxResult = apiService.reAssign(taskExceptionRequest);
if (ajaxResult.isSuccess()){
//获取返回的任务号和新分配的货位
TaskExceptionReceive mydoJobReAssign = BeanUtil.toBean(ajaxResult.get("result"), TaskExceptionReceive.class);
MydoJob wmsJob = new MydoJob();
wmsJob.setInOrOut(mydoJobReAssign.getTaskCode());
if (mydoJobService.selectMydoJobList(wmsJob).size() == 0) {
log.warn("【响应异常】该任务不存在，任务号:{}", mydoJobReAssign.getTaskCode());
return;
}
//更新任务参数
mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
mydoJob.setCargoSpaceId(mydoJobReAssign.getSiteCode());
mydoJob.setExecutionPhase(TASK_EP_DDJ);
mydoJob.setFaultFlag("2");
if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PUT) {
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId());
//更新异常类型【FaultFlag】-1
if ("0".equals(mydoJob.getFaultFlag()) && "1".equals(ddjDeviceExecutionQueue.getSpare1())) {
mydoJob.setStatus("1");
//把执行阶段标记为【入库放货有货】的异常
mydoJob.setExecutionPhase(TASK_EXCEPTION_PUT);
mydoJobService.updateMydoJob(mydoJob);
}
//获取重分的货位重新向堆垛机下发任务
BasCargoSpace basCargoSpace = basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(mydoJob.getCargoSpaceId());
ddjDeviceExecutionQueue.setMbph(basCargoSpace.getThePlatoon());
ddjDeviceExecutionQueue.setMblh(basCargoSpace.getTheColumn());
ddjDeviceExecutionQueue.setMbch(basCargoSpace.getTheFloor());
ddjDeviceExecutionQueue.setDdjxf("0");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
}
// //上报异常 - 向wms请求重分接口
// TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest();
// taskExceptionRequest.setTaskClass(mydoJob.getInOrOut().substring(0, 1));
// taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED));
// taskExceptionRequest.setTaskCode(mydoJob.getWmsTaskNo());
// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么
// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
// taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位");
//
// AjaxResult ajaxResult = apiService.reAssign(taskExceptionRequest);
// if (ajaxResult.isSuccess()){
// //获取返回的任务号和新分配的货位
// TaskExceptionReceive mydoJobReAssign = BeanUtil.toBean(ajaxResult.get("result"), TaskExceptionReceive.class);
//
// MydoJob wmsJob = new MydoJob();
// wmsJob.setWmsTaskNo(mydoJobReAssign.getTaskCode());
// if (mydoJobService.selectMydoJobList(wmsJob).size() == 0) {
// log.warn("【响应异常】该任务不存在，任务号:{}", mydoJobReAssign.getTaskCode());
// return;
// }
//
// //更新任务参数
// mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
// mydoJob.setCargoSpaceId(mydoJobReAssign.getSiteCode());
// mydoJob.setExecutionPhase(TASK_EP_DDJ);
// mydoJob.setFaultFlag("2");
// mydoJobService.updateMydoJob(mydoJob);
//
// //获取重分的货位重新向堆垛机下发任务
// BasCargoSpace basCargoSpace = basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(mydoJob.getCargoSpaceId());
// ddjDeviceExecutionQueue.setMbph(basCargoSpace.getThePlatoon());
// ddjDeviceExecutionQueue.setMblh(basCargoSpace.getTheColumn());
// ddjDeviceExecutionQueue.setMbch(basCargoSpace.getTheFloor());
// ddjDeviceExecutionQueue.setDdjxf("0");
// ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
// }
}
}
// -------------------------------------- 4 取货无货，作废当前任务，重新分配单据 --------------------------------------
//测试数据
// ddj.setCzfs(5);
// ddj.setSbzt(1053);
// ddj.setYxxf(1);
// ddj.setJdbz(3);
// ddj.setRwh(Long.valueOf(51217));
// ddj.setRwh(20021L);
// ddj.setId(1);
// 1.联机自动【5】 2.设备状态-取货无货【1053】 3.执行阶段【<5】（任务执行中）
if (ddj.getCzfs() == 5 && ddj.getSbzt() == 1053 && ddj.getJdbz() < 5) {
if (ddj.getSbzt() == 1053 && ddj.getJdbz() < 5) {
Long rwh = ddj.getRwh();
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
//把执行阶段标记为【出库取货无货】的异常
mydoJob.setExecutionPhase(TASK_EXCEPTION_PICK);
mydoJobService.updateMydoJob(mydoJob);
//无货异常处理
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId());
//找到对应任务 调用api接口 取货无货，重新分配单据
if (ObjUtil.isNotNull(ddjDeviceExecutionQueue)) {
//向wms返回异常信息
TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest();
taskExceptionRequest.setTaskClass(mydoJob.getInOrOut());
taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED));
taskExceptionRequest.setTaskCode(String.valueOf(mydoJob));
taskExceptionRequest.setTaskTypeCode("");//todo 不知道填什么
taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务");
AjaxResult ajaxResult = apiService.reMaterial(taskExceptionRequest);
if (ajaxResult.isSuccess()) {
//作废作业
InvalidMydoJob(rwh, ddj.getId());
//清空/重置【取货无货】的出库异常货位库存信息
basCargoSpaceService.resetCargoSpaceByStockoutException(mydoJob.getCargoSpaceId());
}
if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PICK) {
//把执行阶段标记为【出库取货无货】的异常
mydoJob.setExecutionPhase(TASK_EXCEPTION_PICK);
mydoJobService.updateMydoJob(mydoJob);
}
// //无货异常处理
// DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId());
//
// //找到对应任务 调用api接口 取货无货，重新分配单据
// if (ObjUtil.isNotNull(ddjDeviceExecutionQueue)) {
//
// //向wms返回异常信息
// TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest();
// taskExceptionRequest.setTaskClass(mydoJob.getInOrOut().substring(0, 1));
// taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED));
// taskExceptionRequest.setTaskCode(String.valueOf(mydoJob));
// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么
// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
// taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务");
//
// AjaxResult ajaxResult = apiService.reMaterial(taskExceptionRequest);
// if (ajaxResult.isSuccess()) {
// //作废作业
// InvalidMydoJob(rwh, ddj.getId());
//
// //清空/重置【取货无货】的出库异常货位库存信息
// basCargoSpaceService.resetCargoSpaceByStockoutException(mydoJob.getCargoSpaceId());
// }
// }
}
// -------------------------------------- 5 下发堆垛机任务 --------------------------------------
//重分货位后重下
if (ddj.getYxxf() == 1 && ddj.getCzfs() == 5 && ddj.getSbzt() == 1052) {
if (ddj.getYxxf() == 1 && ddj.getSbzt() == 1052) {
Long rwh = ddj.getRwh();
//查询执行中的作业
@@ -266,16 +281,16 @@ public class DdjThread implements Runnable {
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
mydoJob.setFaultFlag("0");
mydoJobService.updateMydoJob(mydoJob);
log.info("【入库异常】堆垛机放货目标有货，重分货位下发任务成功 rwh:{}", rwh);
log.info("【入库异常】堆垛机放货目标有货，重分货位下发堆垛机任务成功 rwh:{}", rwh);
} else {
log.error("【出库异常】堆垛机放货目标有货，重分货位下发任务失败！！！！！！！");
log.error("【入库异常】重分货位 - 下发堆垛机任务失败！！！！！！！");
}
}
}
}
//正常下发
if (ddj.getYxxf() == 1 && ddj.getCzfs() == 5 && ddj.getSbzt() == 0 ) {
if (ddj.getYxxf() == 1 && ddj.getSbzt() == 0 ) {
//检查是否有正在执行的堆垛机队列
Long rwh = ddj.getRwh();
DdjDeviceExecutionQueue ddjDeviceExecutionQueueRunningParam = new DdjDeviceExecutionQueue();
@@ -348,9 +363,10 @@ public class DdjThread implements Runnable {
int mbch = Convert.toInt(queue.getMbch());
int mlfs = 5;
int xfwc = 1;
int rwlx = Convert.toInt(queue.getSpare1());
int jym = Tools.getJYM(taskNo, yph, ylh, ych, mbph, mblh, mbch, mlfs, rwlx);
byte[] sendData = Tools.sendDataToDevice(taskNo, null, yph, ylh, ych, mbph, mblh, mbch, mlfs, rwlx, xfwc, jym);
int hwlx = Convert.toInt(queue.getSpare1());
// int hwlx = 0;//默认值
int jym = Tools.getJYM(taskNo, yph, ylh, ych, mbph, mblh, mbch, mlfs, hwlx);
byte[] sendData = Tools.sendDataToDevice(taskNo, null, yph, ylh, ych, mbph, mblh, mbch, mlfs, hwlx, xfwc, jym);
if (devId==1){
return PlcDdj1Read.WriteToDDJ("DB61.0", sendData);
}else {

224
ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/PortConvThread.java
View File

@@ -4,15 +4,14 @@ import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSON;
import com.ruoyi.api.domain.wcs2wms.stockin.StockinReceive;
import com.ruoyi.api.service.IApiService;
import com.ruoyi.bas.cargospace.domain.BasCargoSpace;
import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService;
import com.ruoyi.common.ConvException;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.device.ssj.domain.DeviceSsj;
import com.ruoyi.job.domain.JobCallBack;
import com.ruoyi.job.domain.MydoJob;
import com.ruoyi.job.service.IJobCallBackService;
import com.ruoyi.job.service.IMydoJobService;
@@ -31,7 +30,6 @@ import java.util.regex.Pattern;
import static com.ruoyi.common.TaskStatusCode.*;
import static com.ruoyi.common.WmsTaskTypeCode.WMS_TASK_TYPE_STOCKIN;
import static com.ruoyi.common.WmsTaskTypeCode.WMS_TASK_TYPE_STOCKOUT;
import static com.ruoyi.schedule.plcRead.ssj.PlcSsjRead.writeToSsj;
/**
@@ -57,7 +55,7 @@ public class PortConvThread implements Runnable {
ssjCodeList = new HashMap<>();
ArrayList<String> ssjCodes = new ArrayList<>();
ssjCodes.add("G1004");
// ssjCodes.add("L1003");
ssjCodes.add("TD1001");
ssjCodeList.put("portConv", ssjCodes);
apiService = SpringUtils.getBean(IApiService.class);
// agvQueueService = SpringUtils.getBean(IAgvQueueService.class);
@@ -78,8 +76,13 @@ public class PortConvThread implements Runnable {
for (String ssjCode : ssjCodeList.get(type)) {
try {
if (PlcSsjRead.deviceSsjMap.containsKey(ssjCode)) {
inDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode));
// inDispatch1(PlcSsjRead.deviceSsjMap.get(ssjCode));
if (ssjCode == "G1004"){
inDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode));
}
if (ssjCode == "TD1001"){
outDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode));
}
} else {
log.error("设备不存在 ssjCode:{}", ssjCode);
}
@@ -88,6 +91,7 @@ public class PortConvThread implements Runnable {
}
}
break;
}
}
try {
@@ -103,42 +107,42 @@ public class PortConvThread implements Runnable {
public void inDispatch(DeviceSsj inSsjDevice) {
// 测试数据
// inSsjDevice.setInOrOut(1);
// inSsjDevice.setTrayCode("T888888");
// inSsjDevice.setTaskNo(85012);
// inSsjDevice.setTrayCode("T000004503");
// inSsjDevice.setTaskNo(777778);
// inSsjDevice.setKx(0);
// inSsjDevice.setDw(1);
// inSsjDevice.setHeight("1");
// inSsjDevice.setHeight(1);
// inSsjDevice.setWeight("100");
// inSsjDevice.setException(0);
// inSsjDevice.setRkqq(1);
//todo 是否需要校验出入库模式
switch (inSsjDevice.getInOrOut()) {
//---------------------------入库模式---------------------------
case 1:
//---------------------------入口取输送机（叉车取放货位置）---------------------------
//输送机【非空闲】、【输送到位】、【入库请求?】
if (inSsjDevice.getKx() != 1 && inSsjDevice.getDw() == 1) {
//更新入库任务阶段
updateMydoJob(inSsjDevice);
//请求wms获取入库任务
requestMydoJob(inSsjDevice);
}
break;
//---------------------------出库模式---------------------------
case 2:
finishStockoutMydoJob(inSsjDevice);
break;
}
//更新入库任务阶段
updateMydoJob(inSsjDevice);
//请求wms获取入库任务
requestMydoJob(inSsjDevice);
}
/**
* 输送机到位判断校验
* @param inSsjDevice
* @return
*/
private boolean convChecked(DeviceSsj inSsjDevice){
boolean flag = false;
//---------------------------入口取输送机（叉车取放货位置）---------------------------
//输送机【非空闲】、【输送到位】、【入库请求?】
if (inSsjDevice.getKx() != 0) return flag;
if (inSsjDevice.getRkqq() != 1) return flag;
if (inSsjDevice.getHeight() == 0) return flag;
return true;
}
/**
* 请求wms获取wcs任务参数
@@ -146,103 +150,68 @@ public class PortConvThread implements Runnable {
*/
private void requestMydoJob(DeviceSsj inSsjDevice){
//校验：入库请求
if (inSsjDevice.getRkqq() != 1) {
return;
}
if (!convChecked(inSsjDevice)) return;
String errorMessage = "";
AjaxResult ajaxResult;
//请求参数
//初始化请求wms参数
HashMap<String, Object> paramMap = new HashMap<>();
paramMap.put("taskTypeCode", WMS_TASK_TYPE_STOCKIN);//todo wms自定义的任务类型编号
paramMap.put("taskTypeCode", WMS_TASK_TYPE_STOCKIN);//wms自定义的任务类型编号
paramMap.put("reqCode", UUID.randomUUID().toString());//请求码
paramMap.put("cntCode", inSsjDevice.getTrayCode());//容器编号
int height = inSsjDevice.getHeight();
// String weight = inSsjDevice.getWeight();//todo 需要直读重量或从plc读值？
paramMap.put("weight", getWeightByMoxa(MOXA_IP, MOXA_PORT, SO_TIMEOUT_MS));//重量
// String weight = inSsjDevice.getWeight();//不需要直读重量或从plc读值，wms不需要该参数
// paramMap.put("weight", getWeightByMoxa(MOXA_IP, MOXA_PORT, SO_TIMEOUT_MS));//重量
paramMap.put("altimetry", height);//高度
String errorMessage = "";
paramMap.put("adverseCauses", errorMessage);
// if (inSsjDevice.getException() > 0){
// log.warn("【入库异常】{}",errorMessage);
// }
//-----------------校验：入库口异常上报-----------------
switch (inSsjDevice.getException()) {
//外形检测异常
case ConvException.CHECK_SIZE_EXCEPTION:
errorMessage = "外形检测异常-货物超高";
break;
//超重检测
case ConvException.CHECK_OVERWEIGHT_EXCEPTION:
errorMessage = "外形检测异常-货物超重";
break;
//扫码异常
case ConvException.CHECK_BARCODE_EXCEPTION:
if (inSsjDevice.getTrayCode() == "") {
errorMessage = "条码扫描失败:未扫到条码";
}else{
//todo 条码格式校验
errorMessage = "条码扫描异常:格式错误";
}
break;
}
if (inSsjDevice.getException() > 0){
paramMap.put("adverseCauses", errorMessage);
ajaxResult = apiService.createInMydoJobException(paramMap);
if (ajaxResult.isSuccess()) {
//向输送机下发退回
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), "99", 99, 1);
if (i == 1) {
log.warn("【入库异常】{}",errorMessage);
}
}
}
//-----------------校验:条码已有库存-----------------
//-----------------警告校验:条码已有库存-----------------
BasCargoSpace cargoSpace = new BasCargoSpace();
cargoSpace.setTrayCode(inSsjDevice.getTrayCode());
if (!basCargoSpaceService.selectBasCargoSpaceList(cargoSpace).isEmpty()) {
log.warn("【生成wcs任务异常】该托盘号已有库存,托盘条码:{}",inSsjDevice.getTrayCode());
return;
log.warn("【警告】该托盘号已有库存,托盘条码:{}",inSsjDevice.getTrayCode());
}
//-----------------请求生成wcs任务-----------------
/*-----------------请求生成wcs任务----------------- */
ajaxResult = apiService.createMydoJobForStockin(paramMap);
if (ajaxResult.isSuccess()) {
//获取wms下发的任务号和分配货位
//解析wms下发的响应参数（任务号和货位）
StockinReceive result = BeanUtil.toBean(ajaxResult.get("data"), StockinReceive.class);
MydoJob mydoJob = new MydoJob();
mydoJob.setTrayCode(result.getCntCode());
mydoJob.setCargoSpaceId(result.getSiteCode());
mydoJob.setWmsTaskNo(result.getTaskCode());
mydoJob.setJobId(mydoJobService.getJobId("RK"));
mydoJob.setTaskNo(mydoJobService.getTaskNo("1"));
// mydoJob.setTaskNo(result.getTaskCode());//需要确定是否用获取的任务号作为wcs的任务号
//校验：wms分配的货位(排列层)是否合法
if (result.getSiteCode() == null || result.getSiteCode().isEmpty()) {
log.info("【请求参数异常】分配货位:null，无法生成作业，托盘条码:{}",inSsjDevice.getTrayCode());
errorMessage = "wms下发货位错误，任务生成失败！";
paramMap.put("adverseCauses", errorMessage);
apiService.createInMydoJobException(paramMap);
log.info("【响应参数异常】分配货位:null，无法生成作业，托盘条码:{}",inSsjDevice.getTrayCode());
return;
}else {
// mydoJob.setRoadwayId(basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(mydoJob.getCargoSpaceId()).getRoadwayId());
}
mydoJob.setStatus("1");
mydoJob.setInOrOut("1");
mydoJob.setRoadwayId("1");
mydoJob.setEntranceId("G1004");
mydoJob.setExecutionPhase(TASK_EP_CREATE);
mydoJob.setCreateTime(new Date());
// mydoJob.setTraySize(Convert.toStr(inSsjDevice.getTraySize()));
mydoJob.setFaultFlag("0");
mydoJob.setPriority(10L);
//初始化要生成的任务
MydoJob mydoJob = new MydoJob().builder()
// mydoJob.setTaskNo(result.getTaskCode());//如果需要用wms下发的任务号作为wcs的任务号使用
.trayCode(result.getCntCode())
.cargoSpaceId(result.getSiteCode())
.wmsTaskNo(result.getTaskCode())
.jobId(mydoJobService.getJobId("RK"))
.taskNo(mydoJobService.getTaskNo("1"))
.traySize(String.valueOf(inSsjDevice.getHeight()))
.status(TASK_STATUS_CREATED)
.inOrOut("1")
.roadwayId(basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(result.getSiteCode()).getRoadwayId())//获取货位表货位对应的巷道号
.entranceId("G1004")
.executionPhase(TASK_EP_CREATED)
.faultFlag("0")
.priority(10L)
.build();
//如果还没有wcs任务 - 生成一条任务
if (mydoJobService.selectInOrOutMydoJobList(mydoJob).isEmpty()) {
@@ -253,10 +222,10 @@ public class PortConvThread implements Runnable {
}else{
//请求生成wcs任务失败
//todo 向输送机下发退回
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), "99", 99, 1);
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), "99", 2, 1);
//todo 接口调用失败处理
log.info("【入库请求】请求生成wcs作业失败退回，请重试，响应内容:{}", ajaxResult.get("data").toString());
log.info("【入库请求】请求生成wcs作业失败退回，请检查网络或请求参数，请求内容:{}", JSON.toJSONString(paramMap));
}
}
@@ -267,39 +236,43 @@ public class PortConvThread implements Runnable {
*/
private void updateMydoJob(DeviceSsj inSsjDevice){
//检查是否有已经创建成功的任务 - 更新到下一个执行阶段
MydoJob mydoJobStockin = new MydoJob();
mydoJobStockin.setTrayCode(inSsjDevice.getTrayCode());
mydoJobStockin.setExecutionPhase(TASK_EP_CREATE);
if(mydoJobService.selectMydoJobList(mydoJobStockin).isEmpty()){
//输送机扫描有条码但无任务
log.info("【异常任务】请检查条码扫描结果与托盘实际条码是否一致，扫描条码：{}", inSsjDevice.getTrayCode());
}else{
if (!convChecked(inSsjDevice)) return;
//检查是否有已经创建成功的任务(请求成功的入库任务) - 更新到下一个执行阶段
MydoJob mydoJobStockin = new MydoJob().builder()
.trayCode(inSsjDevice.getTrayCode())
.status(TASK_EP_CREATED)
.executionPhase(TASK_EP_CREATED)
.build();
if(!mydoJobService.selectMydoJobList(mydoJobStockin).isEmpty()){
mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0);
//如果已经生成入库任务 - 向输送机下发任务号
//todo 调整输送去向值
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), mydoJobStockin.getTaskNo(), Integer.parseInt(mydoJobStockin.getTraySize()), 1);
//输送去向值【1】
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), mydoJobStockin.getTaskNo(), 1, 1);
// int i = 1;
if (i == 1) {
//写入成功则更新执行阶段
mydoJobStockin.setStatus(TASK_STATUS_RUNNING);
mydoJobStockin.setExecutionPhase(TASK_EP_SSJ);
mydoJobService.updateMydoJob(mydoJobStockin);
log.info("【更新状态】G1004入口输送机下发任务号成功:{}", mydoJobStockin.getTaskNo());
}
}
}
/**
* 输送机出库到位 - 任务出库完成
* @param inSsjDevice
* @param outSsjDevice
*/
private void finishStockoutMydoJob(DeviceSsj inSsjDevice){
private void finishStockoutMydoJob(DeviceSsj outSsjDevice){
//出库到位
if (inSsjDevice.getDw() == 1 && inSsjDevice.getTaskNo() > 0) {
if (outSsjDevice.getDw() == 1 && outSsjDevice.getTaskNo() > 0) {
//查询该出库任务
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(Convert.toLong(inSsjDevice.getTaskNo()));
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(Convert.toLong(outSsjDevice.getTaskNo()));
if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) > 20) {
log.info("【出库到位】设备:{}，位置:{}，任务号:{}，出库到位", "输送线:", inSsjDevice.getDeviceCode(), mydoJob.getTaskNo());
log.info("【出库到位】设备:{}，位置:{}，任务号:{}，出库到位", "输送线:", outSsjDevice.getDeviceCode(), mydoJob.getTaskNo());
mydoJob.setExecutionPhase(TASK_EP_SSJ_STOCKOUT_FINISH);
mydoJobService.updateMydoJob(mydoJob);
mydoJobService.taskFinish(Long.valueOf(mydoJob.getTaskNo()));
@@ -378,6 +351,7 @@ public class PortConvThread implements Runnable {
public void inDispatch1(DeviceSsj ssjDevice) {
//有入库请求就肯定是电气的任务号的作业
if(StrUtil.isNotBlank(ssjDevice.getTrayCode()) && ssjDevice.getRkqq()==1 && ssjDevice.getTaskNo()<1000){
//,如果有正执行的出库作业退回
@@ -422,7 +396,7 @@ public class PortConvThread implements Runnable {
if(ajaxResult.isSuccess()){
MydoJob mydoJob2 = BeanUtil.toBean(ajaxResult.get("data"), MydoJob.class);
mydoJob2.setStatus("1");
mydoJob2.setExecutionPhase(TASK_EP_CREATE);
mydoJob2.setExecutionPhase(TASK_EP_CREATED);
mydoJob2.setCreateTime(new Date());
mydoJob2.setFaultFlag("0");
mydoJob2.setPriority(10L);
@@ -446,6 +420,12 @@ public class PortConvThread implements Runnable {
}
public void outDispatch(DeviceSsj ssjDevice) {
finishStockoutMydoJob(ssjDevice);
}
private static final Map<String, Pattern> PATTERNS = createPatterns();
private static Map<String, Pattern> createPatterns() {

19
ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/RoadConvThread.java
View File

@@ -22,6 +22,8 @@ import lombok.extern.slf4j.Slf4j;
import java.util.*;
import static com.ruoyi.common.ConvType.CONV_ROAD_1;
import static com.ruoyi.common.ConvType.CONV_STOCKOUT;
import static com.ruoyi.common.TaskStatusCode.*;
import static com.ruoyi.common.TaskType.*;
@@ -54,7 +56,7 @@ public class RoadConvThread implements Runnable {
ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class);
//初始化巷道口 排 列 层
//todo 核对堆垛机取放位置的货位编码
roadwayMap.put("L1001", Arrays.asList(2, 0, 1));
roadwayMap.put("L1001", Arrays.asList(2, 1, 1));
// roadwayMap.put("L1004", Arrays.asList(4, 0, 1));
log.info("初始化服务 {}，{}", apiService, agvQueueService);
}
@@ -148,14 +150,17 @@ public class RoadConvThread implements Runnable {
ddjDeviceExecutionQueue.setMbch(Convert.toInt(basCargoSpace.getTheFloor()));
ddjDeviceExecutionQueue.setDdjxf("0");
ddjDeviceExecutionQueue.setMlfs(5);
// ddjDeviceExecutionQueue.setSpare1(mydoJob.getTraySize());
ddjDeviceExecutionQueue.setSpare1(mydoJob.getTraySize());//货物高度
ddjDeviceExecutionQueue.setScsj(DateUtil.formatDateTime(DateUtil.date()));
ddjDeviceExecutionQueue.setRwlx(DDJ_RWLX_3);
ddjDeviceExecutionQueueService.insertDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
//下发后更新任务阶段
mydoJob.setExecutionPhase(TASK_EP_DDJ);
mydoJobService.updateMydoJob(mydoJob);
if (ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueue).size() > 0){
//下发后更新任务阶段
mydoJob.setExecutionPhase(TASK_EP_DDJ);
mydoJobService.updateMydoJob(mydoJob);
}
}
}
}
@@ -172,7 +177,7 @@ public class RoadConvThread implements Runnable {
if(roadSsjDevice.getKx()==1 && roadSsjDevice.getTaskNo() == 0){
//检查是否有入口是【G1004】的入库任务
String exitId = "G1004";
String exitId = CONV_STOCKOUT;
List<MydoJob> inList = mydoJobService.getInJobByEntranceId(exitId);
if(inList.size() == 0){
@@ -204,7 +209,7 @@ public class RoadConvThread implements Runnable {
ddjDeviceExecutionQueue.setMbch(pclList.get(2));
ddjDeviceExecutionQueue.setDdjxf("0");
ddjDeviceExecutionQueue.setMlfs(5);
ddjDeviceExecutionQueue.setSpare1(mydoJob.getTraySize());
ddjDeviceExecutionQueue.setSpare1(mydoJob.getTraySize());//货物高度
ddjDeviceExecutionQueue.setScsj(DateUtil.formatDateTime(DateUtil.date()));
ddjDeviceExecutionQueue.setRwlx(DDJ_RWLX_2);
ddjDeviceExecutionQueueService.insertDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);