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

40
ruoyi-admin/src/main/java/com/ruoyi/api/controller/Wcs2WmsController.java
View File

@@ -21,29 +21,43 @@ public class Wcs2WmsController {
@Autowired
private IWcsPortService wcsPortService;
/**
* 接收wms出库任务
*
* @param stockoutReceive
* @param receiveJob
* @return
*/
@PostMapping("/receiveOutMydoJob")
public AjaxResult receiveOutMydoJob(@RequestBody StockoutReceive stockoutReceive) {
return apiService.receiveOutMydoJob(stockoutReceive);
public AjaxResult receiveOutMydoJob(@RequestBody ReceiveJob receiveJob) {
return apiService.receiveOutMydoJob(receiveJob);
}
/**
* 接收入库任务
*
* @param receiveInJob
* @param receiveJob
* @return
*/
@PostMapping("/receiveInMydoJob")
public AjaxResult receiveInMydoJob(@RequestBody ReceiveJob receiveInJob) {
return apiService.receiveInMydoJob(receiveInJob);
public AjaxResult receiveInMydoJob(@RequestBody ReceiveJob receiveJob) {
return apiService.receiveInMydoJob(receiveJob);
}
/**
* 接收盘点任务
*
* @param receiveJob
* @return
*/
@PostMapping("/receiveInventoryMydoJob")
public AjaxResult receiveInventoryMydoJob(@RequestBody ReceiveJob receiveJob) {
return apiService.receiveInventoryMydoJob(receiveJob);
}
/**
* wms取消任务
@@ -52,7 +66,18 @@ public class Wcs2WmsController {
*/
@PostMapping("/cancelMydoJob")
public AjaxResult cancelMydoJob(@RequestBody JobParam jobParam) {
return apiService.cancelMydoJob(jobParam);
return apiService.cancelTask(jobParam.getTaskNo());
}
/**
* wms手动完成任务
* @param jobParam
* @return
*/
@PostMapping("/manuallyCompeleteMydoJob")
public AjaxResult manuallyCompeleteMydoJob(@RequestBody JobParam jobParam) {
return apiService.manuallyCompeleteTask(jobParam.getTaskNo());
}
@@ -66,6 +91,7 @@ public class Wcs2WmsController {
return apiService.selectWcsPort(wcsPort);
}
/**
* 修改缓存点状态
* @param wcsPort

5
ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/JobParam.java
View File

@@ -23,5 +23,10 @@ public class JobParam {
*/
private String taskNo;
/**
* 货位号
*/
private String cargoSpaceId;
}

23
ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/ReceiveJob.java
View File

@@ -8,6 +8,12 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
public class ReceiveJob {
/**
* 作业号
*/
private String jobId;
/**
* 任务号
*/
@@ -18,6 +24,11 @@ public class ReceiveJob {
*/
private String cargoSpaceId;
/**
* 入口
*/
private String entranceId;
/**
* 出口
*/
@@ -28,21 +39,11 @@ public class ReceiveJob {
*/
private String trayCode;
/**
* 入口
*/
private String entranceId;
/**
* 任务类型
*/
private String inOrOut;
/**
* 作业号
*/
private String jobId;
/**
* 巷道号
*/
@@ -52,4 +53,6 @@ public class ReceiveJob {
*
*/
private String departmentId;
}

162
ruoyi-admin/src/main/java/com/ruoyi/api/service/IApiService.java
View File

@@ -1,5 +1,11 @@
package com.ruoyi.api.service;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson2.JSON;
import com.ruoyi.api.domain.RequestLog;
import com.ruoyi.api.domain.agv.agvCallback.AgvCallbackRequest;
import com.ruoyi.api.domain.agv.agvCallback.AgvCallbackResponse;
@@ -9,6 +15,7 @@ import com.ruoyi.api.domain.agv.continueTask.ContinueTaskRequest;
import com.ruoyi.api.domain.agv.continueTask.ContinueTaskResponse;
import com.ruoyi.api.domain.agv.genAgvSchedulingTask.GenAgvSchedulingTaskRequest;
import com.ruoyi.api.domain.agv.genAgvSchedulingTask.GenAgvSchedulingTaskResponse;
import com.ruoyi.api.domain.agv.genAgvSchedulingTask.PositionCodeData;
import com.ruoyi.api.domain.wcs2wms.JobParam;
import com.ruoyi.api.domain.wcs2wms.ReceiveJob;
import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionRequest;
@@ -19,11 +26,16 @@ import com.ruoyi.common.exception.job.TaskException;
import com.ruoyi.job.domain.MydoJob;
import com.ruoyi.queue.agv.domain.AgvQueue;
import org.aspectj.weaver.loadtime.Aj;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.ruoyi.common.Constant.*;
import static com.ruoyi.common.Constant.CANCEL_TASK_URL;
/**
* 接口记录Service接口
*
@@ -33,6 +45,77 @@ import java.util.Map;
public interface IApiService
{
/**
* 任务到达拣选口
* @param param
* @return
*/
RequestLog finishMydoJob(Map<String, Object> param);
AjaxResult selectWcsPort(WcsPort wcsPort);
AjaxResult updateWcsPort(WcsPort wcsPort);
/**
* 放货有货，重新分配货位
* @param jobParam
* @return
*/
AjaxResult reAssign(JobParam jobParam);
/**
* 取货无货，重新分配单据
* @param jobParam
* @return
*/
AjaxResult reMaterial(JobParam jobParam);
/**
* 入库请求生成作业
*/
AjaxResult createInMydoJob(Map<String, Object> param);
/**
* @@@ FT568 入库请求生成作业 处理了请求响应，适应wms的自定义响应格式
*/
AjaxResult createMydoJobForStockin(Map<String, Object> param);
/**
* 入库请求作业异常反馈（扫码失败、外形、称重等异常）
*/
AjaxResult createInMydoJobException(Map<String, Object> param);
AjaxResult selectMydoJobByNoTrayCode(Map<String, Object> param);
AjaxResult receiveOutMydoJob(ReceiveJob receiveJob);
AjaxResult receiveInMydoJob(ReceiveJob receiveJob);
AjaxResult receiveInventoryMydoJob(ReceiveJob receiveInventoryJob);
AjaxResult selectMydoJobByTrayCodeAndEntranceId(HashMap<String, Object> paramMap);
AjaxResult requestWmsSpace(MydoJob mydoJob);
AjaxResult manuallyCompeleteTask(String taskNo);
AjaxResult cancelTask(String taskNo);
//=============================================AGV相关=============================================
//=============================================AGV相关=============================================
//=============================================AGV相关=============================================
/**
* 生成agv队列
* @param code1 起点
@@ -82,19 +165,7 @@ public interface IApiService
*/
AjaxResult receiveAgvMoveJob(Map<String, String> param);
/**
* 任务到达拣选口
* @param param
* @return
*/
RequestLog finishMydoJob(Map<String, Object> param);
/**
* @@@ FT568 任务完成回传 适应wms的自定义响应格式
* @param param
* @return
*/
RequestLog finishMydoJobForResponseResult(Map<String, Object> param);
AjaxResult deleteAgvTray(AgvQueue agvQueue);
/**
* 下发agv任务
@@ -103,7 +174,6 @@ public interface IApiService
*/
public GenAgvSchedulingTaskResponse requestAgvQueue(AgvQueue agvQueue);
/**
* 取消ctu任务
* @param jobParam
@@ -111,69 +181,5 @@ public interface IApiService
*/
AjaxResult cancelMydoJob(JobParam jobParam);
AjaxResult selectWcsPort(WcsPort wcsPort);
AjaxResult updateWcsPort(WcsPort wcsPort);
/**
* 放货有货，重新分配货位
* @param jobParam
* @return
*/
AjaxResult reAssign(JobParam jobParam);
/**
* 放货有货 （参数类型TaskExceptionRequest）
* @param taskExceptionRequest
* @return
*/
AjaxResult reAssign(TaskExceptionRequest taskExceptionRequest);
/**
* 取货无货，重新分配单据
* @param jobParam
* @return
*/
AjaxResult reMaterial(JobParam jobParam);
/**
* 取货无货（参数类型TaskExceptionRequest）
* @param taskExceptionRequest
* @return
*/
AjaxResult reMaterial(TaskExceptionRequest taskExceptionRequest);
/**
* 入库请求生成作业
*/
AjaxResult createInMydoJob(Map<String, Object> param);
/**
* @@@ FT568 入库请求生成作业 处理了请求响应，适应wms的自定义响应格式
*/
AjaxResult createMydoJobForStockin(Map<String, Object> param);
/**
* 入库请求作业异常反馈（扫码失败、外形、称重等异常）
*/
AjaxResult createInMydoJobException(Map<String, Object> param);
AjaxResult selectMydoJobByNoTrayCode(Map<String, Object> param);
AjaxResult receiveOutMydoJob(StockoutReceive stockoutReceive);
AjaxResult receiveInMydoJob(ReceiveJob receiveInJob);
AjaxResult selectMydoJobByTrayCodeAndEntranceId(HashMap<String, Object> paramMap);
AjaxResult deleteAgvTray(AgvQueue agvQueue);
AjaxResult requestWmsSpace(MydoJob mydoJob);
}

978
ruoyi-admin/src/main/java/com/ruoyi/api/service/impl/ApiServiceImpl.java
View File

File diff suppressed because it is too large Load Diff

27
ruoyi-admin/src/main/java/com/ruoyi/common/ConvType.java
View File

@@ -3,17 +3,32 @@ package com.ruoyi.common;
public class ConvType {
/**
* 出库输送机（到位位置）
* 1#巷道出库输送机（出口到位位置）
*/
public static final String CONV_STOCKOUT = "TD1001";
public static final String ROADWAY1_EXIT = "L1008";
/**
* 入库输送机（到位位置）
* 1#巷道入库输送机（入口源位置）
*/
public static final String CONV_STOCKIN = "G1004";
public static final String ROADWAY1_ENTRANCE = "L1009";
/**
* 1#巷道口输送机（到位位置）
* 2#巷道输送口-2（双向输送机到位位置）
*/
public static final String CONV_ROAD_1 = "L1001";
public static final String ROADWAY2_PORTCONV_2 = "L1006";
/**
* 2#巷道输送口-1（双向输送机到位位置）
*/
public static final String ROADWAY2_PORTCONV_1 = "L1004";
/**
* 3#巷道出库输送机（出口到位位置）
*/
public static final String ROADWAY3_EXIT = "L1001";
/**
* 3#巷道入库输送机（入口源位置）
*/
public static final String ROADWAY3_ENTRANCE = "L1002";
}

2
ruoyi-admin/src/main/java/com/ruoyi/common/GoodsType.java
View File

@@ -18,5 +18,5 @@ public class GoodsType {
/**
* 高度2
*/
public static final String TYPE_HEIGHT_2 = "0";
public static final String TYPE_HEIGHT_2 = "2";
}

33
ruoyi-admin/src/main/java/com/ruoyi/common/TaskStatusCode.java
View File

@@ -30,12 +30,12 @@ public class TaskStatusCode {
/**
* 任务状态-手动完成
*/
public static final String TASK_STATUS_FINISH_MANUAL = "5";
public static final String TASK_STATUS_FINISH_MANUAL = "4";
/**
* 任务状态-作废
*/
public static final String TASK_STATUS_INVALID = "6";
public static final String TASK_STATUS_INVALID = "5";
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 【执行阶段】 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@@ -57,7 +57,7 @@ public class TaskStatusCode {
public static final String TASK_EP_AGV = "2";
/**
* 任务执行阶段 入口输送机
* 任务执行阶段 入口输送机到位
*/
public static final String TASK_EP_SSJ = "3";
@@ -72,24 +72,38 @@ public class TaskStatusCode {
public static final String TASK_EP_DDJ = "5";
/**
* 任务执行阶段 堆垛机放货完成
* 任务执行阶段 堆垛机入库放货完成
*/
public static final String TASK_EP_DDJ_FINISH = "6";
/**
* 任务执行阶段 输送机出库到位-出库完成
* 任务执行阶段 输送机出库输送机到位-出库完成
*/
public static final String TASK_EP_SSJ_STOCKOUT_FINISH = "6";
/**
* 任务执行阶段 任务自动完成
* 任务执行阶段 任务自动完成 （如果不想区分出入库完成可以直接统一使用【自动完成】）
*/
public static final String TASK_EP_FINISH = "6";
/**
* 任务执行阶段 输送机出库到位-盘点出库阶段完成
*/
public static final String TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH = "7";
/**
* 任务执行阶段 堆垛机入库放货完成-盘点回库阶段完成
*/
public static final String TASK_EP_SSJ_INVENTORY_STOCKIN_FINISH = "8";
/**
* 任务执行阶段 任务超时-自动结束当前任务
*/
public static final String TASK_EP_DDJ_FINISH_TIMEOUT = "6_TIMEOUT_FINISH";
public static final String TASK_EP_DDJ_FINISH_TIMEOUT = "TIMEOUT_FINISH";
/**
* 入库异常 - 放货有货
@@ -106,10 +120,7 @@ public class TaskStatusCode {
*/
public static final String TASK_EXCEPTION_PUT_REASSIGN = "STOCKIN_FAULT_REASSIGN";
/**
* 任务执行阶段 回传wms完成
*/
public static final String TASK_EP_WMS_FINISH = "9";
}

23
ruoyi-admin/src/main/java/com/ruoyi/common/TaskType.java
View File

@@ -8,7 +8,28 @@ public class TaskType {
/**
* 默认类型
*/
public static final int STACKER_TYPE_DEFAULT = 0;
public static final int TASKTYPE_DEFAULT = 0;
public static final String TASKTYPE_DEFAULT_STR = "0";
/**
* 常规入库
*/
public static final int TASKTYPE_STOCKIN = 1;
public static final String TASKTYPE_STOCKIN_STR = "1";
/**
* 常规出库
*/
public static final int TASKTYPE_STOCKOUT = 2;
public static final String TASKTYPE_STOCKOUT_STR = "2";
/**
* 盘点出库
*/
public static final int TASKTYPE_INVENTORY = 3;
public static final String TASKTYPE_INVENTORY_STR = "3";
/**
* 1-二楼入出

15
ruoyi-admin/src/main/java/com/ruoyi/job/controller/MydoJobController.java
View File

@@ -114,12 +114,23 @@ public class MydoJobController extends BaseController
@PreAuthorize("@ss.hasAnyPermi('job:mydoJob:outhandFinish')")
@Log(title = "出库手动完成", businessType = BusinessType.OTHER)
@RequestMapping("/outhandFinish")
public AjaxResult manualCompleted(@RequestParam("jobIds")String[] jobIds)
@RequestMapping("/manualCompleted")
public AjaxResult manualCompleted(@RequestParam String[] jobIds)
{
return mydoJobService.outhandFinish(jobIds);
}
/**
* 取消作业
*/
@PreAuthorize("@ss.hasPermi('job:mydoJob:remove')")
@Log(title = "手动取消作业", businessType = BusinessType.DELETE)
@DeleteMapping("/cancelMydoJob")
public AjaxResult cancelMydoJob(@RequestParam String[] jobIds)
{
return mydoJobService.cancelTask(jobIds);
}
@PreAuthorize("@ss.hasAnyPermi('job:mydoJob:resendTaskToEntrance')")
@Log(title = "入口输送机重新下发", businessType = BusinessType.OTHER)
@PutMapping("/resendTaskToEntrance")

6
ruoyi-admin/src/main/java/com/ruoyi/job/domain/MydoJob.java
View File

@@ -1,5 +1,6 @@
package com.ruoyi.job.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;
@@ -21,13 +22,14 @@ import java.util.List;
@NoArgsConstructor
@ToString
@Builder
//@TableName("mydo_job_wcs")
@TableName("mydo_job_wcs")
public class MydoJob extends BaseEntity
{
@TableField(exist = false)
private static final long serialVersionUID = 1L;
/** 任务ID */
// @TableId
@TableId
private String jobId;
/** 任务状态 */

10
ruoyi-admin/src/main/java/com/ruoyi/job/service/IMydoJobService.java
View File

@@ -90,7 +90,15 @@ public interface IMydoJobService
AjaxResult outhandFinish(String[] jobIds);
AjaxResult ManuelTaskFinish(String taskNo);
AjaxResult manuallyCompeleteTask(String taskNo);
AjaxResult manuallyCompeleteTask(String[] jobIds);
AjaxResult cancelTask(String taskNo);
AjaxResult cancelTask(String[] JobIds);
AjaxResult compeleteTimeoutTask(String taskNo);
List<MydoJob> getInJobByEntranceId(String exitId);

287
ruoyi-admin/src/main/java/com/ruoyi/job/service/impl/MydoJobServiceImpl.java
View File

@@ -24,6 +24,7 @@ import com.ruoyi.job.domain.MydoJob;
import com.ruoyi.job.service.IMydoJobService;
import static com.ruoyi.common.TaskStatusCode.TASK_STATUS_FINISH_MANUAL;
import static com.ruoyi.common.TaskStatusCode.TASK_STATUS_INVALID;
import static com.ruoyi.common.WmsTaskTypeCode.*;
/**
@@ -105,16 +106,13 @@ public class MydoJobServiceImpl implements IMydoJobService
@Override
public int deleteMydoJobByJobIds(String[] jobIds)
{
MydoJob mydojob;
for (String jobId : jobIds) {
mydojob = selectMydoJobByJobId(jobId);
mydoJobMapper.insertHistory(jobId);
//当执行任务的【删除】操作时（特殊场景需要手动处理异常导致不需要入库时，此时不需要向回传异常）
// 此处顺便处理对应任务号生成的堆垛机执行队列，省去sql直接表中删记录的操作
if (selectMydoJobByJobId(jobId) != null){
String taskNo = selectMydoJobByJobId(jobId).getTaskNo();
if (ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(taskNo) != null) {
ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(taskNo);
}
}
mydojob.setStatus(TASK_STATUS_INVALID);
updateMydoJob(mydojob);
}
return mydoJobMapper.deleteMydoJobByJobIds(jobIds);
@@ -150,14 +148,30 @@ public class MydoJobServiceImpl implements IMydoJobService
throw new RuntimeException(map.get("v_result").toString());
}
}
/**
* 任务自动完成
* @param rwh
* @return
*/
@Override
public boolean taskFinish(Long rwh) {
MydoJob task = selectMydoJobByTaskNo(rwh);
insertHistory(task.getJobId());
deleteMydoJobByJobId(task.getJobId());
ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(task.getTaskNo());
MydoJob task = selectMydoJobByTaskNo(rwh);
//插入历史表
insertHistory(task.getJobId());
//删除执行中的作业
deleteMydoJobByJobId(task.getJobId());
//移除“可能存在”的堆垛机队列
DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(task.getTaskNo());
if (queue != null){
ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(task.getTaskNo());
}
//插入回传表
JobCallBack jobCallBack = new JobCallBack();
jobCallBack.setType(Integer.valueOf(task.getInOrOut()) < 20 ? "1" : "2");
jobCallBack.setMydoJobId(task.getJobId());
@@ -168,9 +182,13 @@ public class MydoJobServiceImpl implements IMydoJobService
jobCallBack.setReqCode(UUID.randomUUID().toString().replace("-", ""));
jobCallBack.setTaskCode(task.getWmsTaskNo());
jobCallBackService.insertJobCallBack(jobCallBack);
log.info("【任务自动完成】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", task.getJobId(), rwh);
return true;
}
@Override
public boolean InvalidMydoJob(Long rwh, Integer id) {
HashMap<String, Object> map = new HashMap<>();
@@ -187,21 +205,25 @@ public class MydoJobServiceImpl implements IMydoJobService
}
}
@Override
public MydoJob selectMydoJobByExitList(List<String> exitList ) {
return mydoJobMapper.selectMydoJobByExitList(exitList);
}
@Override
public MydoJob selectMydoJobByExitList1(String exitId ,String roadwayId) {
return mydoJobMapper.selectMydoJobByExitList1(exitId,roadwayId);
}
@Override
public void insertHistory(String jobId) {
mydoJobMapper.insertHistory(jobId);
}
@Override
public List<MydoJob> selectInOrOutMydoJobList(MydoJob mydoJob) {
return mydoJobMapper.selectInOrOutMydoJobList(mydoJob);
@@ -232,61 +254,43 @@ public class MydoJobServiceImpl implements IMydoJobService
mydoJob.setStatus(TASK_STATUS_FINISH_MANUAL);
updateMydoJob(mydoJob);
//插入历史表
mydoJobMapper.insertHistory(jobId);
JobCallBack jobCallBack = new JobCallBack();
jobCallBack.setType(mydoJob.getInOrOut());
jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms自定义的任务类型
jobCallBack.setMydoJobId(mydoJob.getJobId());
jobCallBack.setStatus("0");
jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo()));
jobCallBack.setCreateTime(new Date());
jobCallBack.setTaskCode(mydoJob.getWmsTaskNo());
jobCallBack.setRetry(0);
jobCallBack.setReqCode(UUID.randomUUID().toString());
jobCallBackService.insertJobCallBack(jobCallBack);
//移除实时任务
mydoJobMapper.deleteMydoJobByJobId(jobId);
log.info("【人工操作】手动完成wcs任务，wcs任务号:{}，wms任务号:{}", mydoJob.getTaskNo(), mydoJob.getWmsTaskNo());
DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo());
try {
if (queue != null)
{
DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class);
ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish);
ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo());
log.info("【人工操作】移除堆垛机队列，wcs任务号:{}", mydoJob.getTaskNo());
}
} catch (Exception e) {
}
}
return AjaxResult.success("操作成功");
}
/**
* 手动处理指定【任务号】的作业
* 手动完成指定【任务号】的作业
* @param taskNo
* @return
*/
@Override
public AjaxResult ManuelTaskFinish(String taskNo) {
public AjaxResult manuallyCompeleteTask(String taskNo) {
//获取所有符合【任务号】的作业
MydoJob mydoJob = mydoJobMapper.selectMydoJobByTaskNo(taskNo);
mydoJobMapper.insertHistory(mydoJob.getInOrOut());
if (mydoJob == null){
return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作");
}
//标记状态为【手动完成】插入历史表
mydoJob.setStatus(TASK_STATUS_FINISH_MANUAL);
updateMydoJob(mydoJob);
mydoJobMapper.insertHistory(mydoJob.getJobId());
try {
//处理堆垛机执行队列和历史记录
DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo());
if (queue != null){
DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class);
ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish);
}
} catch (Exception e) {
log.warn("【人工操作】手动完成操作失败:{}", e.getMessage());
}
JobCallBack jobCallBack = new JobCallBack();
jobCallBack.setType(mydoJob.getInOrOut());
jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型
@@ -301,10 +305,179 @@ public class MydoJobServiceImpl implements IMydoJobService
mydoJobMapper.deleteMydoJobByTaskNo(taskNo);
log.info("【任务手动完成】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", mydoJob.getJobId(), taskNo);
return AjaxResult.success("操作成功");
}
/**
* 手动完成指定【任务号】的作业（数组类型参数）
* @param jobIds
* @return
*/
@Override
public AjaxResult manuallyCompeleteTask(String[] jobIds) {
for (String jobId : jobIds) {
//获取所有符合【任务号】的作业
MydoJob mydoJob = mydoJobMapper.selectMydoJobByJobId(jobId);
if (mydoJob == null){
return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作");
}
//标记状态为【手动完成】插入历史表
mydoJob.setStatus(TASK_STATUS_FINISH_MANUAL);
updateMydoJob(mydoJob);
mydoJobMapper.insertHistory(jobId);
try {
//处理堆垛机执行队列和历史记录
DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo());
if (queue != null){
DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class);
ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish);
}
} catch (Exception e) {
log.warn("【人工操作】手动完成操作失败:{}", e.getMessage());
}
JobCallBack jobCallBack = new JobCallBack();
jobCallBack.setType(mydoJob.getInOrOut());
jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型
jobCallBack.setMydoJobId(jobId);
jobCallBack.setStatus("0");
jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo()));
jobCallBack.setCreateTime(new Date());
jobCallBack.setTaskCode(mydoJob.getWmsTaskNo());
jobCallBack.setRetry(0);
jobCallBack.setReqCode(UUID.randomUUID().toString());
jobCallBackService.insertJobCallBack(jobCallBack);
mydoJobMapper.deleteMydoJobByJobId(jobId);
log.info("【任务手动完成】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", jobId, mydoJob.getTaskNo());
}
return AjaxResult.success("操作成功");
}
/**
* 手动作废指定【任务号】的作业
* @param taskNo
* @return
*/
@Override
public AjaxResult cancelTask(String taskNo) {
//获取所有符合【任务号】的作业
MydoJob mydoJob = mydoJobMapper.selectMydoJobByTaskNo(taskNo);
if (mydoJob == null){
return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作");
}
//标记状态为【手动作废】插入历史表
mydoJob.setStatus(TASK_STATUS_INVALID);
updateMydoJob(mydoJob);
mydoJobMapper.insertHistory(mydoJob.getJobId());
try {
//处理堆垛机执行队列和历史记录
DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo());
if (queue != null){
DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class);
ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish);
}
} catch (Exception e) {
log.warn("【人工操作】手动作废操作失败:{}", e.getMessage());
}
JobCallBack jobCallBack = new JobCallBack();
jobCallBack.setType(mydoJob.getInOrOut());
jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型
jobCallBack.setMydoJobId(mydoJob.getJobId());
jobCallBack.setStatus("0");
jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo()));
jobCallBack.setCreateTime(new Date());
jobCallBack.setTaskCode(mydoJob.getWmsTaskNo());
jobCallBack.setRetry(0);
jobCallBack.setReqCode(UUID.randomUUID().toString());
jobCallBackService.insertJobCallBack(jobCallBack);
mydoJobMapper.deleteMydoJobByTaskNo(taskNo);
log.info("【任务手动取消】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", mydoJob.getJobId(), taskNo);
return AjaxResult.success("操作成功");
}
/**
* 手动作废指定【任务号】的作业（数组类型参数）
* @param JobIds
* @return
*/
@Override
public AjaxResult cancelTask(String[] JobIds) {
for (String jobId : JobIds) {
//获取所有符合【任务号】的作业
MydoJob mydoJob = mydoJobMapper.selectMydoJobByJobId(jobId);
if (mydoJob == null){
return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作");
}
//标记状态为【手动作废】插入历史表
mydoJob.setStatus(TASK_STATUS_INVALID);
updateMydoJob(mydoJob);
mydoJobMapper.insertHistory(jobId);
try {
//处理堆垛机执行队列和历史记录
DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo());
if (queue != null){
DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class);
ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish);
}
} catch (Exception e) {
log.warn("【人工操作】手动作废操作失败:{}", e.getMessage());
}
JobCallBack jobCallBack = new JobCallBack();
jobCallBack.setType(mydoJob.getInOrOut());
jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型
jobCallBack.setMydoJobId(jobId);
jobCallBack.setStatus("0");
jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo()));
jobCallBack.setCreateTime(new Date());
jobCallBack.setTaskCode(mydoJob.getWmsTaskNo());
jobCallBack.setRetry(0);
jobCallBack.setReqCode(UUID.randomUUID().toString());
jobCallBackService.insertJobCallBack(jobCallBack);
mydoJobMapper.deleteMydoJobByJobId(jobId);
log.info("【任务手动取消】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", jobId, mydoJob.getTaskNo());
}
return AjaxResult.success("操作成功");
}
/**
* 遗留任务超时自动完成
* @param taskNo
* @return
*/
@Override
public AjaxResult compeleteTimeoutTask(String taskNo) {
//todo
return null;
}
@Override
public List<MydoJob> getInJobByEntranceId(String exitId) {
@@ -341,6 +514,10 @@ public class MydoJobServiceImpl implements IMydoJobService
return mydoJobMapper.selectJobByTaskNo(taskNo);
}
/**
* 获取本地生成作业号
* @param type RK-入库 CK-出库

6
ruoyi-admin/src/main/java/com/ruoyi/queue/ddj/service/impl/DdjDeviceExecutionQueueFinishServiceImpl.java
View File

@@ -1,6 +1,9 @@
package com.ruoyi.queue.ddj.service.impl;
import java.util.List;
import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue;
import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.queue.ddj.mapper.DdjDeviceExecutionQueueFinishMapper;
@@ -19,6 +22,9 @@ public class DdjDeviceExecutionQueueFinishServiceImpl implements IDdjDeviceExecu
@Autowired
private DdjDeviceExecutionQueueFinishMapper ddjDeviceExecutionQueueFinishMapper;
@Autowired
private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService;
/**
* 查询堆垛机完成队列
*

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);

1
ruoyi-admin/src/main/resources/application.yml
View File

@@ -113,6 +113,7 @@ mybatis:
# mapper-locations: classpath*:mapper/**/*Mapper.xml
# # 实体类别名包（让 XML 中能用 User 而非全限定名）
# type-aliases-package: com.ruoyi.**.domain
# config-location: classpath:mybatis/mybatis-config.xml
# configuration:
# map-underscore-to-camel-case: true
# cache-enabled: false

5
ruoyi-admin/src/main/resources/logback.xml
View File

@@ -5,9 +5,6 @@
<!-- 日志输出格式 -->
<property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />
<!-- 输出编码格式 -->
<property name="log.charset" value="UTF-8" />
<!-- 控制台输出 -->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
@@ -27,7 +24,6 @@
</rollingPolicy>
<encoder>
<pattern>${log.pattern}</pattern>
<charset>${log.charset}</charset>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<!-- 过滤的级别 -->
@@ -50,7 +46,6 @@
</rollingPolicy>
<encoder>
<pattern>${log.pattern}</pattern>
<charset>${log.charset}</charset>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<!-- 过滤的级别 -->