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

初始化

Browse Source
This commit is contained in:
lsymicc
2026-06-29 15:29:20 +08:00
parent 4c590f515f
commit 415543a723
23 changed files with 1949 additions and 739 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ruoyi-admin/src/main/java/com/ruoyi/schedule/ScheduleThread.java
View File

@@ -7,7 +7,6 @@ import com.ruoyi.device.ssj.domain.DeviceSsj;
import com.ruoyi.device.ssj.service.IDeviceSsjService;
import com.ruoyi.common.domain.PlcConnectInfo;
import com.ruoyi.schedule.plcRead.ddj.PlcDdj1Read;
import com.ruoyi.schedule.plcRead.ddj.PlcDdj2Read;
import com.ruoyi.schedule.plcRead.ssj.PlcSsjRead;
import com.ruoyi.common.domain.CustomThread;
import com.ruoyi.schedule.scheduleTask.ddj.DdjThread;

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

@@ -2,6 +2,7 @@ package com.ruoyi.schedule.scheduleTask;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.UUID;
import com.ruoyi.api.domain.wcs2wms.JobParam;
import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionReceive;
import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionRequest;
import com.ruoyi.api.service.IApiService;
@@ -44,14 +45,17 @@ public class TaskHandler {
private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService;
private static final int DEFAULTTIMEINTERVAL = 2000;
private static final int TIMEINTERVAL_DEFAULT = 2000;
private static final int TIMEINTERVAL_3000 = 3000;
private static final int TIMEINTERVAL_5000 = 5000;
private static final int TIMEINTERVAL_10000 = 10000;
/**
* 处理未正常移除的【堆垛机执行完成】或【出库到位】的遗留任务
* 【自动完成】 - 处理标记为自动完成的任务
*/
// @Scheduled(fixedDelay = 3000)
public void mydoJobHandler() {
@Scheduled(fixedDelay = TIMEINTERVAL_3000)
public void mydoJobAutoFinish() {
//查询所有标记为【已完成】的任务
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().executionPhase(TASK_EP_FINISH).build()
@@ -64,10 +68,27 @@ public class TaskHandler {
}
/**
* 【手动完成】 - 查询并处理标记为已经手动完成的任务
*/
@Scheduled(fixedDelay = TIMEINTERVAL_3000)
public void manualFinishmydoJob() {
//查询所有标记为【已完成】的任务
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().status(TASK_STATUS_FINISH_MANUAL).build()
);
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
mydoJobService.manuallyCompeleteTask(job.getTaskNo());
}
}
}
/**
* 【手动作废】 - 查询并处理标记为已经作废的任务
*/
//@Scheduled(fixedDelay = 3000)
@Scheduled(fixedDelay = TIMEINTERVAL_3000)
public void cancelMydoJob(){
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().status(TASK_STATUS_INVALID).build()
@@ -75,24 +96,24 @@ public class TaskHandler {
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
mydoJobService.ManuelTaskFinish(job.getTaskNo());
mydoJobService.cancelTask(job.getTaskNo());
}
}
}
/**
* 【手动完成】 - 查询并处理标记为已经手动完成的任务
* 【超时自动完成】 - 处理未正常移除的【堆垛机执行完成】或【出库到位】的遗留任务
*/
//@Scheduled(fixedDelay = 3000)
public void finishMydoJob(){
@Scheduled(fixedDelay = TIMEINTERVAL_10000)
public void finishMydoJobTimeout(){
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().status(TASK_STATUS_FINISH_MANUAL).build()
new MydoJob().builder().status(TASK_EP_DDJ_FINISH_TIMEOUT).build()
);
if (!jobs.isEmpty()) {
for (MydoJob job : jobs) {
mydoJobService.ManuelTaskFinish(job.getTaskNo());
mydoJobService.compeleteTimeoutTask(job.getTaskNo());
}
}
}
@@ -101,16 +122,61 @@ public class TaskHandler {
/**
* 定时扫描未回传或回传异常的任务记录
*/
@Scheduled(fixedDelay = 3000)
@Scheduled(fixedDelay = TIMEINTERVAL_3000)
public void jobCallBack() {
jobCallBackService.jobCallBack();
}
/**
* 【出库异常】 - 【取货无货】处理方法
*/
@Scheduled(fixedDelay = TIMEINTERVAL_DEFAULT)
public void stockoutExceptionHandler() {
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PICK).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(String.valueOf(job.getWmsTaskNo()));
// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么
// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
// taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务");
JobParam param = new JobParam();
param.setJobId(job.getJobId());
param.setTaskNo(job.getTaskNo());
param.setTrayCode(job.getTrayCode());
param.setCargoSpaceId(job.getCargoSpaceId());
AjaxResult ajaxResult = apiService.reMaterial(param);
if (ajaxResult.isSuccess()){
mydoJobService.InvalidMydoJob(Long.valueOf(job.getTaskNo()), Integer.valueOf(job.getRoadwayId()));
//清空/重置【取货无货】的出库异常货位库存信息
basCargoSpaceService.resetCargoSpaceByStockoutException(job.getCargoSpaceId());
log.info("【出库异常】堆垛机取货时目标位置无货，当前任务已作废，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId());
}else{
log.info("【出库异常】堆垛机取货时目标位置无货，异常上报请求失败，请咨询操作管理员，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId());
}
}
}
}
/**
* 【入库异常-请求重分】 - 【放货有货】处理方法
*/
@Scheduled(fixedDelay = DEFAULTTIMEINTERVAL)
@Scheduled(fixedDelay = TIMEINTERVAL_DEFAULT)
public void stockinExceptionHandler() {
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PUT).build()
@@ -120,15 +186,21 @@ public class TaskHandler {
for (MydoJob job : jobs) {
String oldCargo = job.getCargoSpaceId();
//上报异常 - 向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);//wms自定义文本
taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位");
// 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);//wms自定义文本
// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", ""));
// taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位");
AjaxResult ajaxResult = apiService.reAssign(taskExceptionRequest);
JobParam param = new JobParam();
param.setJobId(job.getJobId());
param.setTaskNo(job.getTaskNo());
param.setTrayCode(job.getTrayCode());
param.setCargoSpaceId(job.getCargoSpaceId());
AjaxResult ajaxResult = apiService.reAssign(param);
if (ajaxResult.isSuccess()){
//获取返回的任务号和新分配的货位
TaskExceptionReceive mydoJobReAssign = BeanUtil.toBean(ajaxResult.get("data"), TaskExceptionReceive.class);
@@ -158,49 +230,10 @@ public class TaskHandler {
}
/**
* 【出库异常】 - 【取货无货】处理方法
*/
@Scheduled(fixedDelay = DEFAULTTIMEINTERVAL)
public void stockoutExceptionHandler() {
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PICK).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(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());
log.info("【出库异常】堆垛机取货时目标位置无货，当前任务已作废，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId());
}else{
log.info("【出库异常】堆垛机取货时目标位置无货，异常上报请求失败，请咨询操作管理员，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId());
}
}
}
}
/**
* 【入库异常-重分完成】 - 堆垛机重新下发
*/
@Scheduled(fixedDelay = DEFAULTTIMEINTERVAL)
@Scheduled(fixedDelay = TIMEINTERVAL_DEFAULT)
public void sendTaskForStacker(){
List<MydoJob> jobs = mydoJobService.selectMydoJobList(
new MydoJob().builder().executionPhase(TASK_EXCEPTION_PUT_REASSIGN).build()

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

@@ -76,7 +76,7 @@ public class DdjThread implements Runnable {
for (String ddjCode : ddjCodeList.get(type)) {
try {
if ("ddj1".equals(ddjCode)) {
ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode));
// ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode));
}
//PlcDdj2Read.deviceDdjMap.containsKey(ddjCode)
// if ("ddj2".equals(ddjCode)) {

335
ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_1.java Normal file
View File

@@ -0,0 +1,335 @@
package com.ruoyi.schedule.scheduleTask.ddj;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjUtil;
import com.ruoyi.api.service.IApiService;
import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.device.ddj.domain.MsgDdj;
import com.ruoyi.job.domain.MydoJob;
import com.ruoyi.job.service.IMydoJobService;
import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue;
import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueFinishService;
import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService;
import com.ruoyi.schedule.plcRead.ddj.PlcDdj1Read;
import com.ruoyi.schedule.plcRead.ddj.PlcDdj2Read;
import com.ruoyi.schedule.plcRead.util.Tools;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import static com.ruoyi.common.TaskStatusCode.*;
@Slf4j
public class DdjThread_1 implements Runnable {
public HashMap<String, List<String>> ddjCodeList;
private IApiService apiService;
private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService;
private IDdjDeviceExecutionQueueFinishService ddjDeviceExecutionQueueFinishService;
private IMydoJobService mydoJobService;
private IBasCargoSpaceService basCargoSpaceService;
public boolean isRun = true;
public void init() {
//todo 获取设备编码列表
ddjCodeList = new HashMap<>();
ArrayList<String> ddjCodes = new ArrayList<>();
ddjCodes.add("ddj1");
// ddjCodes.add("ddj2");
ddjCodeList.put("ddj", ddjCodes);
apiService = SpringUtils.getBean(IApiService.class);
ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class);
ddjDeviceExecutionQueueFinishService = SpringUtils.getBean(IDdjDeviceExecutionQueueFinishService.class);
basCargoSpaceService = SpringUtils.getBean(IBasCargoSpaceService.class);
mydoJobService = SpringUtils.getBean(IMydoJobService.class);
log.info("初始化服务 {}，{},{},{}", apiService, ddjDeviceExecutionQueueService, ddjDeviceExecutionQueueFinishService,mydoJobService);
}
@Override
public void run() {
init();
while (isRun) {
for (String type : ddjCodeList.keySet()) {
if ("ddj".equals(type)) {
for (String ddjCode : ddjCodeList.get(type)) {
try {
if ("ddj1".equals(ddjCode)) {
ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode));
}
} catch (RuntimeException e) {
log.error(e.getMessage(), e);
}
}
}
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
private void ddjTask(MsgDdj ddj) {
/* --------------------------------------【1 处理已经完成的作业】--------------------------------------
堆垛机线程进来后第一件事先进行堆垛机正执行任务的账务处理
以防存在漏处理，没处理的情况发生
*/
//非【联机自动】状态
if (ddj.getCzfs() != 5) return;
// 检查当前堆垛机参数 - 是否有执行中的作业
// 1.联机自动【5】 2.设备状态【0】 3.执行阶段【0】【5】（无执行中的任务）
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);
mydoJobService.updateMydoJob(mydoJob);
//执行wms回传 - 方法在存储过程【proc_mydojob_finish】中
// ddjTaskFinish(rwh, ddj.getId());
log.info("【堆垛机执行】设备编号：" + ddj.getId() + " 执行完成，任务结束，任务号："+ddj.getRwh());
}
}
//-------------------------------------- 【2 更新执行阶段】 --------------------------------------
// 1.联机自动【5】 2.设备状态 - 运行中【1】 3.执行阶段【2】
if (ddj.getSbzt() == 1 && ddj.getJdbz() == 2) {
//根据堆垛机上任务号，修改任务执行阶段
Long rwh = ddj.getRwh();
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId());
if (ddjDeviceExecutionQueue != null && !"1".equals(ddjDeviceExecutionQueue.getSpare1())) {
//修改队列执行阶段
ddjDeviceExecutionQueue.setRwzt(ddj.getJdbz());
ddjDeviceExecutionQueue.setSpare1("1");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
}
}
/* -------------------------------------- 【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.getSbzt() == 1052 && ddj.getJdbz() < 5 && ddj.getYxxf() == 1) {
// 判断堆垛机上任务是否已重分，若未重分，则调用接口，请求重分货位
Long rwh = ddj.getRwh();
//查询正在执行中的【任务号】获取堆垛机队列
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
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);
log.info("【入库异常】堆垛机放货时目标位置有货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh);
}
}
}
// -------------------------------------- 4 取货无货，作废当前任务，重新分配单据 --------------------------------------
//测试数据
// ddj.setCzfs(5);
// ddj.setSbzt(1053);
// ddj.setYxxf(1);
// ddj.setJdbz(3);
// ddj.setRwh(20021L);
// ddj.setId(1);
// 1.联机自动【5】 2.设备状态-取货无货【1053】 3.执行阶段【<5】（任务执行中）
if (ddj.getSbzt() == 1053 && ddj.getJdbz() < 5) {
Long rwh = ddj.getRwh();
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PICK) {
//把执行阶段标记为【出库取货无货】的异常
mydoJob.setExecutionPhase(TASK_EXCEPTION_PICK);
mydoJobService.updateMydoJob(mydoJob);
log.info("【出库异常】堆垛机取货时目标位置无货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh);
}
// //无货异常处理
// 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.getSbzt() == 1052) {
Long rwh = ddj.getRwh();
//查询执行中的作业
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
//该任务存在且【FaultFlag】为 2-已重分完成
if (ObjUtil.isNotNull(mydoJob) && "2".equals(mydoJob.getFaultFlag())) {
//判断任务是否重分完成
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId());
if (ObjUtil.isNotNull(ddjDeviceExecutionQueue) && "0".equals(ddjDeviceExecutionQueue.getDdjxf())) {
//重新下发堆垛机任务
int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue);
if (i == 1) {
//更新开始时间，修改ddjxf为已下发1
ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date()));
ddjDeviceExecutionQueue.setDdjxf("1");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
mydoJob.setFaultFlag("0");
mydoJobService.updateMydoJob(mydoJob);
log.info("【入库异常】重分货位下发堆垛机任务成功，当前任务号:{}", rwh);
} else {
log.error("【入库异常】重分货位 - 下发堆垛机任务失败！！！！！！！");
}
}
}
}
//正常下发
if (ddj.getYxxf() == 1 && ddj.getSbzt() == 0 ) {
//检查是否有正在执行的堆垛机队列
Long rwh = ddj.getRwh();
DdjDeviceExecutionQueue ddjDeviceExecutionQueueRunningParam = new DdjDeviceExecutionQueue();
ddjDeviceExecutionQueueRunningParam.setDdjxf("1");
//ddjDeviceExecutionQueueRunningParam.setSpare1("1");
ddjDeviceExecutionQueueRunningParam.setDevId(ddj.getId());
List<DdjDeviceExecutionQueue> ddjDeviceExecutionRunningQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueRunningParam);
if (CollUtil.isNotEmpty(ddjDeviceExecutionRunningQueues)) {
log.error("【提示】堆垛机有正在执行的队列，任务号: {}，请检查该任务号的wcs作业是否已经手动处理" , ddjDeviceExecutionRunningQueues.get(0).getRwh());
return;
}
//对堆垛机执行队列中无已下发队列
DdjDeviceExecutionQueue ddjDeviceExecutionQueueParam = new DdjDeviceExecutionQueue();
ddjDeviceExecutionQueueParam.setDdjxf("0");
ddjDeviceExecutionQueueParam.setDevId(ddj.getId());
List<DdjDeviceExecutionQueue> ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueParam);
//取堆垛机队列中，生成时间最早的执行队列下发
if (CollUtil.isNotEmpty(ddjDeviceExecutionQueues)) {
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueues.get(0);
int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue);
if (i == 1) {
//更新开始时间，修改ddjxf为已下发1
ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date()));
ddjDeviceExecutionQueue.setDdjxf("1");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
log.info("【堆垛机入库】下发任务成功，任务执行中, 任务号:{}", ddjDeviceExecutionQueue.getRwh());
} else {
log.error("【堆垛机入库】执行异常, 堆垛机下发任务失败！");
}
}
}
}
/**
* 作废作业
*
* @param rwh 作业单号
* @param id 作业单id
*/
private void InvalidMydoJob(Long rwh, Integer id) {
mydoJobService.InvalidMydoJob(rwh, id);
}
/**
* 堆垛机任务完成
*
* @param rwh 作业单号
* @param id 作业单id
*/
private void ddjTaskFinish(Long rwh, Integer id) {
mydoJobService.ddjTaskFinish(rwh, id);
}
/**
* 给堆垛机下发任务
*
* @param queue 堆垛机执行的队列
*/
private int issuedDDJTask(Integer devId, DdjDeviceExecutionQueue queue) {
int taskNo = Convert.toInt(queue.getRwh());
int yph = Convert.toInt(queue.getYph());
int ylh = Convert.toInt(queue.getYlh());
int ych = Convert.toInt(queue.getYch());
int mbph = Convert.toInt(queue.getMbph());
int mblh = Convert.toInt(queue.getMblh());
int mbch = Convert.toInt(queue.getMbch());
int mlfs = 5;
int xfwc = 1;
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 {
return PlcDdj2Read.WriteToDDJ("DB61.0", sendData);
}
}
}

333
ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_2.java Normal file
View File

@@ -0,0 +1,333 @@
package com.ruoyi.schedule.scheduleTask.ddj;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjUtil;
import com.ruoyi.api.service.IApiService;
import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.device.ddj.domain.MsgDdj;
import com.ruoyi.job.domain.MydoJob;
import com.ruoyi.job.service.IMydoJobService;
import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue;
import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueFinishService;
import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService;
import com.ruoyi.schedule.plcRead.ddj.PlcDdj1Read;
import com.ruoyi.schedule.plcRead.ddj.PlcDdj2Read;
import com.ruoyi.schedule.plcRead.util.Tools;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import static com.ruoyi.common.TaskStatusCode.*;
@Slf4j
public class DdjThread_2 implements Runnable {
public HashMap<String, List<String>> ddjCodeList;
private IApiService apiService;
private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService;
private IDdjDeviceExecutionQueueFinishService ddjDeviceExecutionQueueFinishService;
private IMydoJobService mydoJobService;
private IBasCargoSpaceService basCargoSpaceService;
public boolean isRun = true;
public void init() {
//todo 获取设备编码列表
ddjCodeList = new HashMap<>();
ArrayList<String> ddjCodes = new ArrayList<>();
ddjCodes.add("ddj2");
// ddjCodes.add("ddj2");
ddjCodeList.put("ddj", ddjCodes);
apiService = SpringUtils.getBean(IApiService.class);
ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class);
ddjDeviceExecutionQueueFinishService = SpringUtils.getBean(IDdjDeviceExecutionQueueFinishService.class);
basCargoSpaceService = SpringUtils.getBean(IBasCargoSpaceService.class);
mydoJobService = SpringUtils.getBean(IMydoJobService.class);
log.info("初始化服务 {}，{},{},{}", apiService, ddjDeviceExecutionQueueService, ddjDeviceExecutionQueueFinishService,mydoJobService);
}
@Override
public void run() {
init();
while (isRun) {
for (String type : ddjCodeList.keySet()) {
if ("ddj".equals(type)) {
for (String ddjCode : ddjCodeList.get(type)) {
try {
if ("ddj2".equals(ddjCode)) {
ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode));
}
} catch (RuntimeException e) {
log.error(e.getMessage(), e);
}
}
}
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
private void ddjTask(MsgDdj ddj) {
/* --------------------------------------【1 处理已经完成的作业】--------------------------------------
堆垛机线程进来后第一件事先进行堆垛机正执行任务的账务处理
以防存在漏处理，没处理的情况发生
*/
//非【联机自动】状态
if (ddj.getCzfs() != 5) return;
// 检查当前堆垛机参数 - 是否有执行中的作业
// 1.联机自动【5】 2.设备状态【0】 3.执行阶段【0】【5】（无执行中的任务）
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);
mydoJobService.updateMydoJob(mydoJob);
//回传完成信号 - 方法在存储过程【proc_mydojob_finish】中
// ddjTaskFinish(rwh, ddj.getId());
log.info("【堆垛机入库】堆垛机编号：" + ddj.getId() + " 执行完成，任务结束，任务号："+ddj.getRwh());
}
}
//-------------------------------------- 【2 更新执行阶段】 --------------------------------------
// 1.联机自动【5】 2.设备状态 - 运行中【1】 3.执行阶段【2】
if (ddj.getSbzt() == 1 && ddj.getJdbz() == 2) {
//根据堆垛机上任务号，修改任务执行阶段
Long rwh = ddj.getRwh();
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId());
if (ddjDeviceExecutionQueue != null && !"1".equals(ddjDeviceExecutionQueue.getSpare1())) {
//修改队列执行阶段
ddjDeviceExecutionQueue.setRwzt(ddj.getJdbz());
ddjDeviceExecutionQueue.setSpare1("1");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
}
}
/* -------------------------------------- 【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.getSbzt() == 1052 && ddj.getJdbz() < 5 && ddj.getYxxf() == 1) {
// 判断堆垛机上任务是否已重分，若未重分，则调用接口，请求重分货位
Long rwh = ddj.getRwh();
//查询正在执行中的【任务号】获取堆垛机队列
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
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);
log.info("【入库异常】堆垛机放货时目标位置有货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh);
}
}
}
// -------------------------------------- 4 取货无货，作废当前任务，重新分配单据 --------------------------------------
//测试数据
// ddj.setCzfs(5);
// ddj.setSbzt(1053);
// ddj.setYxxf(1);
// ddj.setJdbz(3);
// ddj.setRwh(20021L);
// ddj.setId(1);
// 1.联机自动【5】 2.设备状态-取货无货【1053】 3.执行阶段【<5】（任务执行中）
if (ddj.getSbzt() == 1053 && ddj.getJdbz() < 5) {
Long rwh = ddj.getRwh();
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PICK) {
//把执行阶段标记为【出库取货无货】的异常
mydoJob.setExecutionPhase(TASK_EXCEPTION_PICK);
mydoJobService.updateMydoJob(mydoJob);
log.info("【出库异常】堆垛机取货时目标位置无货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh);
}
// //无货异常处理
// 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.getSbzt() == 1052) {
Long rwh = ddj.getRwh();
//查询执行中的作业
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh);
//该任务存在且【FaultFlag】为 2-已重分完成
if (ObjUtil.isNotNull(mydoJob) && "2".equals(mydoJob.getFaultFlag())) {
//判断任务是否重分完成
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId());
if (ObjUtil.isNotNull(ddjDeviceExecutionQueue) && "0".equals(ddjDeviceExecutionQueue.getDdjxf())) {
//重新下发堆垛机任务
int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue);
if (i == 1) {
//更新开始时间，修改ddjxf为已下发1
ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date()));
ddjDeviceExecutionQueue.setDdjxf("1");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
mydoJob.setFaultFlag("0");
mydoJobService.updateMydoJob(mydoJob);
log.info("【入库异常】重分货位下发堆垛机任务成功，当前任务号:{}", rwh);
} else {
log.error("【入库异常】重分货位 - 下发堆垛机任务失败！！！！！！！");
}
}
}
}
//正常下发
if (ddj.getYxxf() == 1 && ddj.getSbzt() == 0 ) {
//检查是否有正在执行的堆垛机队列
Long rwh = ddj.getRwh();
DdjDeviceExecutionQueue ddjDeviceExecutionQueueRunningParam = new DdjDeviceExecutionQueue();
ddjDeviceExecutionQueueRunningParam.setDdjxf("1");
//ddjDeviceExecutionQueueRunningParam.setSpare1("1");
ddjDeviceExecutionQueueRunningParam.setDevId(ddj.getId());
List<DdjDeviceExecutionQueue> ddjDeviceExecutionRunningQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueRunningParam);
if (CollUtil.isNotEmpty(ddjDeviceExecutionRunningQueues)) {
log.error("【提示】堆垛机有正在执行的队列，任务号: {}，请检查该任务号的wcs作业是否已经手动处理" , ddjDeviceExecutionRunningQueues.get(0).getRwh());
return;
}
//对堆垛机执行队列中无已下发队列
DdjDeviceExecutionQueue ddjDeviceExecutionQueueParam = new DdjDeviceExecutionQueue();
ddjDeviceExecutionQueueParam.setDdjxf("0");
ddjDeviceExecutionQueueParam.setDevId(ddj.getId());
List<DdjDeviceExecutionQueue> ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueParam);
//取堆垛机队列中，生成时间最早的执行队列下发
if (CollUtil.isNotEmpty(ddjDeviceExecutionQueues)) {
DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueues.get(0);
int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue);
if (i == 1) {
//更新开始时间，修改ddjxf为已下发1
ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date()));
ddjDeviceExecutionQueue.setDdjxf("1");
ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue);
log.info("【堆垛机入库】下发任务成功，任务执行中, 任务号:{}", ddjDeviceExecutionQueue.getRwh());
} else {
log.error("【堆垛机入库】执行异常, 堆垛机下发任务失败！");
}
}
}
}
/**
* 作废作业
*
* @param rwh 作业单号
* @param id 作业单id
*/
private void InvalidMydoJob(Long rwh, Integer id) {
mydoJobService.InvalidMydoJob(rwh, id);
}
/**
* 堆垛机任务完成
*
* @param rwh 作业单号
* @param id 作业单id
*/
private void ddjTaskFinish(Long rwh, Integer id) {
mydoJobService.ddjTaskFinish(rwh, id);
}
/**
* 给堆垛机下发任务
*
* @param queue 堆垛机执行的队列
*/
private int issuedDDJTask(Integer devId, DdjDeviceExecutionQueue queue) {
int taskNo = Convert.toInt(queue.getRwh());
int yph = Convert.toInt(queue.getYph());
int ylh = Convert.toInt(queue.getYlh());
int ych = Convert.toInt(queue.getYch());
int mbph = Convert.toInt(queue.getMbph());
int mblh = Convert.toInt(queue.getMblh());
int mbch = Convert.toInt(queue.getMbch());
int mlfs = 5;
int xfwc = 1;
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 {
return PlcDdj2Read.WriteToDDJ("DB61.0", sendData);
}
}
}

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

@@ -32,6 +32,7 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static com.ruoyi.common.TaskStatusCode.*;
import static com.ruoyi.common.TaskType.*;
import static com.ruoyi.common.WmsTaskTypeCode.WMS_TASK_TYPE_STOCKIN;
import static com.ruoyi.schedule.plcRead.ssj.PlcSsjRead.writeToSsj;
@@ -58,8 +59,8 @@ public class PortConvThread implements Runnable {
public void init() {
ssjCodeList = new HashMap<>();
ArrayList<String> ssjCodes = new ArrayList<>();
ssjCodes.add("G1004");
ssjCodes.add("TD1001");
ssjCodes.add("L1008");
ssjCodes.add("L1009");
ssjCodeList.put("portConv", ssjCodes);
apiService = SpringUtils.getBean(IApiService.class);
// agvQueueService = SpringUtils.getBean(IAgvQueueService.class);
@@ -81,13 +82,7 @@ public class PortConvThread implements Runnable {
for (String ssjCode : ssjCodeList.get(type)) {
try {
if (PlcSsjRead.deviceSsjMap.containsKey(ssjCode)) {
if (ssjCode == "G1004"){
inDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode));
}
if (ssjCode == "TD1001"){
outDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode));
}
Schedule(PlcSsjRead.deviceSsjMap.get(ssjCode));
} else {
log.error("设备不存在 ssjCode:{}", ssjCode);
}
@@ -100,7 +95,7 @@ public class PortConvThread implements Runnable {
}
}
try {
Thread.sleep(3000);
Thread.sleep(1500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
@@ -108,9 +103,14 @@ public class PortConvThread implements Runnable {
}
public void Schedule(DeviceSsj deviceSsj){
public void inDispatch(DeviceSsj inSsjDevice) {
// 测试数据
switch (deviceSsj.getDeviceCode()){
//1#巷道入库（单向）
case "L1009":
//3#巷道入库（单向）
case "L1002":
// 测试数据
// inSsjDevice.setInOrOut(1);
// inSsjDevice.setTrayCode("T000004503");
// inSsjDevice.setTaskNo(777778);
@@ -121,22 +121,53 @@ public class PortConvThread implements Runnable {
// inSsjDevice.setException(0);
// inSsjDevice.setRkqq(1);
//输送机状态
if (!convChecked(inSsjDevice)) return;
//更新入库任务阶段
updateMydoJob(inSsjDevice);
//请求wms获取入库任务
requestMydoJob(inSsjDevice);
//到位校验
if (!portConvChecked(deviceSsj)) return;
//更新入库任务阶段
updateMydoJob(deviceSsj);
//请求wms获取入库任务
//requestMydoJob(deviceSsj);
break;
//1#巷道出库口（单向）
case "L1008":
//3#巷道出库口（单向）
case "L1001":
//出库完成
finishStockoutMydoJob(deviceSsj);
//盘点出库
finishInventoryStockoutMydoJob(deviceSsj);
break;
//2#巷道出库口（双向）
case "L1004":
//2#巷道出库口（双向）
case "L1006":
//更新入库任务阶段
updateMydoJob(deviceSsj);
//出库完成
finishStockoutMydoJob(deviceSsj);
//盘点出库
finishInventoryStockoutMydoJob(deviceSsj);
break;
}
}
/**
* 输送机到位判断校验
* @param inSsjDevice
* @return
*/
private boolean convChecked(DeviceSsj inSsjDevice){
private boolean portConvChecked(DeviceSsj inSsjDevice){
boolean flag = false;
//---------------------------入口取输送机（叉车取放货位置）---------------------------
@@ -165,19 +196,9 @@ public class PortConvThread implements Runnable {
).size();
if (count > 0) {
//如果查到输送机有已经该条码的入库作业 - 把该作业更新为初始状态（未向入库输送机下发任务号的阶段）
// 省去入库输送机口的手动作废操作，自动更新任务至初始阶段
// mydoJobService.updateMydoJob(
// new MydoJob().builder()
// .status("1")
// .executionPhase("0")
// .build()
// );
return;
}
String errorMessage = "";
AjaxResult ajaxResult;
@@ -257,22 +278,27 @@ public class PortConvThread implements Runnable {
}
}
/**
* 更新入库任务阶段
* @param inSsjDevice
*/
private void updateMydoJob(DeviceSsj inSsjDevice){
//-------------------------------------------常规入库-------------------------------------------
//检查是否有已经创建成功的任务(请求成功的入库任务) - 更新到下一个执行阶段
MydoJob mydoJobStockin = new MydoJob().builder()
.trayCode(inSsjDevice.getTrayCode())
.status(TASK_STATUS_CREATED)
.executionPhase(TASK_EP_CREATED)
.entranceId(inSsjDevice.getDeviceCode())
.build();
if(!mydoJobService.selectMydoJobList(mydoJobStockin).isEmpty()){
mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0);
//如果已经生成入库任务 - 向输送机下发任务号
//输送去向值【1】
mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0);
//输送机去向值【1】
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), mydoJobStockin.getTaskNo(), 1, 1);
// int i = 1;
if (i == 1) {
@@ -281,10 +307,36 @@ public class PortConvThread implements Runnable {
mydoJobStockin.setExecutionPhase(TASK_EP_SSJ);
mydoJobStockin.setStartTime(DateUtil.formatDateTime(DateUtil.date()));
mydoJobService.updateMydoJob(mydoJobStockin);
log.info("【更新状态】G1004入口输送机下发成功,任务号:{},入库执行中", mydoJobStockin.getTaskNo());
log.info("【更新状态】G1009入口输送机下发成功,任务号:{},入库执行中", mydoJobStockin.getTaskNo());
}
}
//-------------------------------------------盘点回库-------------------------------------------
//检查是否有已经创建成功的任务(请求成功的入库任务) - 更新到下一个执行阶段
mydoJobStockin = new MydoJob().builder()
.trayCode(inSsjDevice.getTrayCode())
.status(TASK_STATUS_RUNNING)
.executionPhase(TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH)
.build();
if(!mydoJobService.selectMydoJobList(mydoJobStockin).isEmpty()){
//如果已经生成入库任务 - 向输送机下发任务号
mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0);
//输送机去向值【1】
int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), mydoJobStockin.getTaskNo(), 1, 1);
// int i = 1;
if (i == 1) {
//写入成功则更新执行阶段
mydoJobStockin.setExecutionPhase(TASK_EP_SSJ);
mydoJobStockin.setStartTime(DateUtil.formatDateTime(DateUtil.date()));
mydoJobService.updateMydoJob(mydoJobStockin);
log.info("【更新状态】入口输送机{}下发成功,任务号:{},盘点回库执行中", inSsjDevice.getDeviceCode(), mydoJobStockin.getTaskNo());
}
}
}
@@ -298,16 +350,49 @@ public class PortConvThread implements Runnable {
if (outSsjDevice.getDw() == 1 && outSsjDevice.getTaskNo() > 0) {
//查询该出库任务
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(Convert.toLong(outSsjDevice.getTaskNo()));
if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) > 20) {
log.info("【出库完成】去向:{}，出库货位:{}，任务号:{}，出库到位", "任务结束", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo());
if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) == TASKTYPE_STOCKOUT) {
log.info("【出库完成】去向:{}，出库货位:{}，任务号:{}，出库到位, 任务结束", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo());
mydoJob.setExecutionPhase(TASK_EP_SSJ_STOCKOUT_FINISH);
mydoJobService.updateMydoJob(mydoJob);
mydoJobService.taskFinish(Long.valueOf(mydoJob.getTaskNo()));
}
//盘点任务出库到位不结束任务
if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) == TASKTYPE_STOCKOUT) {
log.info("【盘点出库完成】去向:{}，出库货位:{}，任务号:{}，盘点出库到位, 等待盘点回库", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo());
mydoJob.setExecutionPhase(TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH);
mydoJobService.updateMydoJob(mydoJob);
}
}
}
/**
* 输送机出库到位 - 盘点任务出库阶段完成
* 出库完成在升降位置，即【TD1001】判断完成
* @param outSsjDevice
*/
private void finishInventoryStockoutMydoJob(DeviceSsj outSsjDevice){
//出库到位
if (outSsjDevice.getDw() == 1 && outSsjDevice.getTaskNo() > 0) {
//查询该出库任务
MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(Convert.toLong(outSsjDevice.getTaskNo()));
if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) == TASKTYPE_INVENTORY) {
log.info("【盘点出库完成】去向:{}，出库货位:{}，任务号:{}，出库到位", "盘点出库完成，等待执行回库", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo());
mydoJob.setExecutionPhase(TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH);
mydoJobService.updateMydoJob(mydoJob);
// mydoJobService.taskFinish(Long.valueOf(mydoJob.getTaskNo()));
}
}
}
// ====== 【请按实际修改】======
private static final String MOXA_IP = "192.168.1.200"; // NPort 5110 的 IP
private static final int MOXA_PORT = 4001; // NPort 配置的 Local Port
@@ -376,10 +461,6 @@ public class PortConvThread implements Runnable {
public void inDispatch1(DeviceSsj ssjDevice) {
//有入库请求就肯定是电气的任务号的作业
@@ -450,16 +531,6 @@ public class PortConvThread implements Runnable {
}
public void outDispatch(DeviceSsj ssjDevice) {
//出库完成
finishStockoutMydoJob(ssjDevice);
}

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

@@ -1,6 +1,5 @@
package com.ruoyi.schedule.scheduleTask.ssj;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
@@ -9,7 +8,6 @@ import cn.hutool.core.util.ObjUtil;
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.common.utils.spring.SpringUtils;
import com.ruoyi.device.ssj.domain.DeviceSsj;
import com.ruoyi.job.domain.MydoJob;
@@ -22,8 +20,7 @@ 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.ConvType.ROADWAY1_EXIT;
import static com.ruoyi.common.TaskStatusCode.*;
import static com.ruoyi.common.TaskType.*;
@@ -47,7 +44,7 @@ public class RoadConvThread implements Runnable {
ssjCodeList = new HashMap<>();
ArrayList<String> ssjCodes = new ArrayList<>();
// ssjCodes.add("L1002");
ssjCodes.add("L1001");
ssjCodes.add("L1010");
ssjCodeList.put("roadConv", ssjCodes);
apiService = SpringUtils.getBean(IApiService.class);
agvQueueService = SpringUtils.getBean(IAgvQueueService.class);
@@ -56,7 +53,7 @@ public class RoadConvThread implements Runnable {
ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class);
//初始化巷道口 排 列 层
//todo 核对堆垛机取放位置的货位编码
roadwayMap.put("L1001", Arrays.asList(2, 1, 1));
roadwayMap.put("L1010", Arrays.asList(1, 1, 1));
// roadwayMap.put("L1004", Arrays.asList(4, 0, 1));
log.info("初始化服务 {}，{}", apiService, agvQueueService);
}
@@ -72,7 +69,7 @@ public class RoadConvThread implements Runnable {
for (String ssjCode : ssjCodeList.get(type)) {
try {
if (PlcSsjRead.deviceSsjMap.containsKey(ssjCode)) {
inDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode));
schedule(PlcSsjRead.deviceSsjMap.get(ssjCode));
} else {
log.error("设备不存在 ssjCode{}", ssjCode);
}
@@ -93,15 +90,55 @@ public class RoadConvThread implements Runnable {
}
public void inDispatch(DeviceSsj roadSsjDevice) {
public void schedule(DeviceSsj roadSsjDevice) {
sendStackerIn(roadSsjDevice);
switch (roadSsjDevice.getDeviceCode()){
//1#巷道入库（单向）
case "L1010":
//3#巷道入库（单向）
case "L1003":
//到位校验
if (!roadConvChecked(roadSsjDevice)) return;
//更新入库任务阶段
sendStackerIn(roadSsjDevice);
//请求wms获取入库任务
//requestMydoJob(deviceSsj);
break;
//1#巷道出库口（单向） -- FT577项目巷道1和巷道3出库位置为单输送机，故此处【出库完成】的方法移至端口输送机线程【PortConvThread】中执行
case "L1008":
//3#巷道出库口（单向）
case "L1001":
//出库完成
// finishStockoutMydoJob(deviceSsj);
sendStackerOut(roadSsjDevice);
break;
}
sendStackerOut(roadSsjDevice);
}
/**
* 输送机到位判断校验
* @param inSsjDevice
* @return
*/
private boolean roadConvChecked(DeviceSsj inSsjDevice){
boolean flag = false;
//---------------------------巷道口取放货输送机---------------------------
//输送机【任务号】和【到位】校验
if (inSsjDevice.getTaskNo() == 0 || inSsjDevice.getDw() == 0) return flag;
return true;
}
/**
* 向堆垛机发送【入库】任务
* @param roadSsjDevice
@@ -129,8 +166,11 @@ public class RoadConvThread implements Runnable {
// 检查任务属性：【任务已存在】、执行阶段-【巷道口输送机到位】、任务类型-【入库】 → 下发堆垛机执行队列
if (mydoJob.getExecutionPhase().equals(TASK_EP_ROADWAY_SSJ) && Convert.toInt(mydoJob.getInOrOut()) < 20) {
//弯轨堆垛机设备编号使用货位区域编号对应
int devId = Convert.toInt(basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(mydoJob.getCargoSpaceId()).getCargoAreaId());
//检查堆垛机是否在正在执行中/已经有执行队列
List<DdjDeviceExecutionQueue> ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueListByRwlx(DDJ_RWLX_3, Convert.toInt(mydoJob.getRoadwayId()));
List<DdjDeviceExecutionQueue> ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueListByRwlx(DDJ_RWLX_3, devId);
BasCargoSpace basCargoSpace = basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(mydoJob.getCargoSpaceId());
List<Integer> pclList = roadwayMap.get(roadSsjDevice.getDeviceCode());
@@ -140,7 +180,7 @@ public class RoadConvThread implements Runnable {
ddjDeviceExecutionQueue.setUuid(IdUtil.simpleUUID());
ddjDeviceExecutionQueue.setRwh(Convert.toLong(mydoJob.getTaskNo()));
ddjDeviceExecutionQueue.setDevName(mydoJob.getRoadwayId());
ddjDeviceExecutionQueue.setDevId(Convert.toInt(mydoJob.getRoadwayId()));
ddjDeviceExecutionQueue.setDevId(devId);
ddjDeviceExecutionQueue.setRwzt(0);
ddjDeviceExecutionQueue.setYph(pclList.get(0));
ddjDeviceExecutionQueue.setYlh(pclList.get(1));
@@ -176,11 +216,11 @@ public class RoadConvThread implements Runnable {
//检查巷道口输送机是否空闲
if(roadSsjDevice.getKx()==1 && roadSsjDevice.getTaskNo() == 0){
//检查是否有入口是【G1004】的入库任务
String exitId = CONV_STOCKOUT;
List<MydoJob> inList = mydoJobService.getInJobByEntranceId(exitId);
//检查是否有入口是1#巷道的出库任务
String exitId = ROADWAY1_EXIT;
MydoJob job = mydoJobService.selectMydoJobByExitId(exitId);
if(inList.size() == 0){
if(job == null){
//检查是否有出库任务
MydoJob mydoJob = mydoJobService.selectMydoJobByExitId(exitId);