huojin
/
Byd_Dg_Java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

no message

main
HUOJIN\92525 2025-02-20 14:31:32 +08:00
parent 9ebba40069
commit 0514b2b39f
20 changed files with 772 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
youchain-system/src/main/java/com/youchain/appupdate/service/impl/BydAppServiceImpl.java
View File

@ -216,6 +216,9 @@ public class BydAppServiceImpl implements BydAppService {
//刷新出库单状态
pickService.refreshPickStatus(task.getPickDetail().getPick());
//生成叫料任务
taskService.callJlTask(pick);
//成品原托盘返库；单品不回库
if (BaseStatus.GD_TYPE_CT.equals(pick.getOrderType())) {
this.returnFBAgvTask(task);

8
youchain-system/src/main/java/com/youchain/basicdata/repository/StockRepository.java
View File

@ -43,12 +43,6 @@ public interface StockRepository extends JpaRepository<Stock, Long>, JpaSpecific
@Query(" from Stock s where s.point.code = :pointCode")
Stock findByPointCode(String pointCode);
@Query(" from Stock s where s.point.area.name = :areaName " +
" and s.point.id > 0 " +
" and s.point.enabled=true" +
" and s.point.status = 'USED'" +
" and s.status = :status " +
" and s.enabled = true " +
" and s.code not in (select agv.stockCode from AgvTask agv where agv.status not in ('FINISH','CANCEL') ) ")
@Query(" from Stock s where s.point.area.name = :areaName and s.point.id > 0 and s.point.enabled=true and s.point.status = 'USED' and s.status = :status and s.enabled = true ")
List<Stock> findByFreeOrUsedStock(String areaName, String status);
}

13
youchain-system/src/main/java/com/youchain/businessdata/domain/AgvTask.java
View File

@ -20,6 +20,7 @@ import lombok.Data;
import cn.hutool.core.bean.BeanUtil;
import io.swagger.annotations.ApiModelProperty;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.sql.Timestamp;
@ -27,9 +28,9 @@ import java.io.Serializable;
import java.util.Date;
/**
* @author baobinglin
* @website https://eladmin.vip
* @description /
* @author baobinglin
* @date 2023-08-18
**/
@Entity
@ -43,17 +44,14 @@ public class AgvTask extends BaseEntity implements Serializable {
private Long id;
@Column(name = "`stock_code`")
@NotBlank
@ApiModelProperty(value = "容器号")
private String stockCode;
@Column(name = "`stock_type_code`")
@NotBlank
@ApiModelProperty(value = "")
private String stockTypeCode;
@Column(name = "`start_slot_code`",nullable = false)
@NotBlank
@Column(name = "`start_slot_code`")
@ApiModelProperty(value = "起点位置")
private String startSlotCode;
@ -66,7 +64,6 @@ public class AgvTask extends BaseEntity implements Serializable {
private String slotCode;
@Column(name = "`status`", nullable = false)
@NotBlank
@ApiModelProperty(value = "任务状态")
private String status;
@ -79,7 +76,6 @@ public class AgvTask extends BaseEntity implements Serializable {
private String jobId;
@Column(name = "`job_type`", nullable = false)
@NotBlank
@ApiModelProperty(value = "工作类型")
/**
* 01：料箱
@ -137,6 +133,7 @@ public class AgvTask extends BaseEntity implements Serializable {
/**
* 添加搬运任务
*
* @param type 任务类型-入库/出库
* @param stockCode 料车号
* @param startSlotCode 起始位置(取料箱点位;料箱当前放置的货位码;取料箱时之前是否需要
@ -145,7 +142,6 @@ public class AgvTask extends BaseEntity implements Serializable {
* 确认)中间用 ; 隔开 例如 14;1-001;false
* @param status 任务状态，直接下发还是排队下发
* @param jobType 任务类型-货 架 ( 托 盘 ) 移动:RACK_MOVE
*
*/
public AgvTask(String type, String stockCode, String startSlotCode, String endSlotCode, String status, String jobType) {
this.type = type;
@ -155,6 +151,7 @@ public class AgvTask extends BaseEntity implements Serializable {
this.status = status;
this.jobType = jobType;
}
public void copy(AgvTask source) {
BeanUtil.copyProperties(source, this, CopyOptions.create().setIgnoreNullValue(true));
}

9
youchain-system/src/main/java/com/youchain/businessdata/domain/Pick.java
View File

@ -100,7 +100,10 @@ public class Pick extends BaseEntity implements Serializable {
@Column(name = "`source_id`")
@ApiModelProperty(value = "回传状态")
private Long sourceId;/** 0失败；1.成功*/
private Long sourceId;
/**
* 0失败；1.成功
*/
@OneToOne
@JoinColumn(name = "`dept_id`", nullable = false)
@ -108,6 +111,10 @@ public class Pick extends BaseEntity implements Serializable {
@ApiModelProperty(value = "仓库")
private Dept dept;
@Column(name = "`priority`")
@ApiModelProperty(value = "优先级")
private int priority=0;
public void copy(Pick source) {
BeanUtil.copyProperties(source, this, CopyOptions.create().setIgnoreNullValue(true));
}

5
youchain-system/src/main/java/com/youchain/businessdata/repository/AgvTaskRepository.java
View File

@ -40,9 +40,10 @@ public interface AgvTaskRepository extends JpaRepository<AgvTask, Long>, JpaSpec
/**
* 查询待执行的备料、叫料、叫料返库任务
* 'PICK','CALL_PICK','CALL_RETURN'
*/
@Query(value = " from AgvTask agv where agv.type in ('PICK','CALL_PICK','CALL_RETURN') and agv.status='OPEN' order by agv.createTime ")
List<AgvTask> findOpenByAgvTask();
@Query(value = " from AgvTask agv where agv.type=:type and agv.status='OPEN' order by agv.createTime ")
List<AgvTask> findOpenByAgvTask(String type);
/**
* 翻包返库时，查询起点是否有多条不同容器的任务(不包括当前任务)

4
youchain-system/src/main/java/com/youchain/businessdata/repository/TaskRepository.java
View File

@ -51,8 +51,8 @@ public interface TaskRepository extends JpaRepository<Task, Long>, JpaSpecificat
*
* @param pickId 出库单ID
*/
@Query("from Task t where t.pickDetail.pick.id =:pickId and t.planQty > t.moveQty and t.agvTask.id is null")
List<Task> findByPickNotAllTask(Long pickId);
@Query("from Task t where t.planQty > t.moveQty and t.agvTask.id is null")
List<Task> findByPickNotAllTask();
/**
* 根据出库单查询已完成的Task集合

18
youchain-system/src/main/java/com/youchain/businessdata/rest/MesController.java
View File

@ -51,10 +51,10 @@ public class MesController {
String itemCode = zpjlZj.getItemCode();//物料代码
String station = zpjlZj.getStation();//需求工位
String pointCode = zpjlZj.getPointCode();//需求点位
mesService.itemCall(orderNo, itemCode, station, pointCode);
return successResponse("叫料成功!");
String result = mesService.itemCall(orderNo, itemCode, station, pointCode);
return successResponse(result);
} catch (Exception e) {
return badResponse("叫料失败:" + e.getMessage());
return successResponse("叫料失败:" + e.getMessage());
}
}
@ -68,10 +68,10 @@ public class MesController {
String completeCode = zpjlCt.getCompleteCode();//成套代码
String station = zpjlCt.getStation();//需求工位
String pointCode = zpjlCt.getPointCode();//需求点位
mesService.bigItemCall(orderNo, completeCode, station, pointCode);
return successResponse("叫料成功!");
String result = mesService.bigItemCall(orderNo, completeCode, station, pointCode);
return successResponse(result);
} catch (Exception e) {
return badResponse("叫料失败：" + e.getMessage());
return successResponse("叫料失败：" + e.getMessage());
}
}
@ -90,10 +90,10 @@ public class MesController {
@AnonymousAccess
public ResponseEntity<Object> transTask(@Validated @RequestBody TransTask transTask) {
try {
mesService.performTransportTask(transTask);
return successResponse("下发成功!");
String result = mesService.performTransportTask(transTask);
return successResponse(result);
} catch (Exception e) {
return badResponse("下发失败!" + e.getMessage());
return successResponse("下发失败!" + e.getMessage());
}
}

13
youchain-system/src/main/java/com/youchain/businessdata/service/AgvTaskService.java
View File

@ -110,6 +110,15 @@ public interface AgvTaskService {
*/
List<AgvTask> findRepeat(String stockCode, String srcPointCode, String endPointCode);
/**
* 根据起点查询是否有重复任务
*
* @param startSlotCode 点位
* @param type 任务类型
* @param jobType 作业类型
*/
Boolean findByStartSlotCode(String startSlotCode, String type, String jobType);
/**
* 根据终点查询是否有重复任务
*
@ -121,6 +130,7 @@ public interface AgvTaskService {
/**
* 叉车任务一个一个下发
*
* @param endSlotCode 终点
* @param type 任务类型
* @param jobType 作业类型
@ -131,7 +141,7 @@ public interface AgvTaskService {
/**
* 查询打开的任务并轮询下发
*/
List<AgvTask> findOpenByAgvTask();
List<AgvTask> findOpenByAgvTask(String type);
/**
* 翻包返库时，查询起点是否有多条不同容器的任务(不包括当前任务)
@ -143,6 +153,7 @@ public interface AgvTaskService {
/**
* 根据状态查询任务
*
* @param status 状态
* @return List<AgvTask>
*/

6
youchain-system/src/main/java/com/youchain/businessdata/service/MesService.java
View File

@ -21,7 +21,7 @@ public interface MesService {
* @param station->需求工位
* @param pointCode->需求点位
*/
void itemCall(String gdNo, String itemCode, String station, String pointCode);
String itemCall(String gdNo, String itemCode, String station, String pointCode);
/**
* 成品叫料-小件
@ -31,13 +31,13 @@ public interface MesService {
* @param station->需求工位
* @param pointCode->需求点位
*/
void bigItemCall(String gdNo, String completeCode, String station, String pointCode);
String bigItemCall(String gdNo, String completeCode, String station, String pointCode);
/**
* 搬运任务
*
* @param transTask 搬运任务
*/
void performTransportTask(TransTask transTask);
String performTransportTask(TransTask transTask);
}

6
youchain-system/src/main/java/com/youchain/businessdata/service/TaskService.java
View File

@ -128,9 +128,8 @@ public interface TaskService {
/**
* 根据出库单查询未完成的Task集合
*
* @param pickId 出库单Id
*/
List<Task> findByPickNotAllTask(Long pickId);
List<Task> findByPickNotAllTask();
/**
* 根据出库单查询已完成的Task集合
@ -174,9 +173,8 @@ public interface TaskService {
/**
* 定时任务轮询出库单备料
*
* @param pick 出库单
*/
void materialPick(Pick pick);
void materialPick();
/**
* 定时任务轮询叫料反空车至备料缓存区

16
youchain-system/src/main/java/com/youchain/businessdata/service/impl/AgvTaskServiceImpl.java
View File

@ -142,6 +142,18 @@ public class AgvTaskServiceImpl implements AgvTaskService {
return agvTaskRepository.findRepeat(stockCode, srcPointCode, endPointCode);
}
@Override
public Boolean findByStartSlotCode(String startSlotCode, String type, String jobType) {
String hql = " from AgvTask agv " +
" where agv.startSlotCode='" + startSlotCode + "' " +
" and agv.type='" + type + "' " +
" and agv.jobType='" + jobType + "' " +
" and agv.status in ('OPEN','ATCALL','UP_CONTAINER') ";
Query query = entityMapper.createQuery(hql);
List<AgvTask> agvTaskList = query.getResultList();
return agvTaskList.isEmpty();
}
@Override
public Boolean findByEndSlotCode(String endSlotCode, String type, String jobType) {
String hql = " from AgvTask agv " +
@ -167,8 +179,8 @@ public class AgvTaskServiceImpl implements AgvTaskService {
}
@Override
public List<AgvTask> findOpenByAgvTask() {
return agvTaskRepository.findOpenByAgvTask();
public List<AgvTask> findOpenByAgvTask(String type) {
return agvTaskRepository.findOpenByAgvTask(type);
}
@Override

325
youchain-system/src/main/java/com/youchain/businessdata/service/impl/MesServiceImpl.java
View File

@ -9,6 +9,7 @@ import com.youchain.basicdata.domain.Item;
import com.youchain.basicdata.domain.Point;
import com.youchain.basicdata.domain.Stock;
import com.youchain.basicdata.repository.ItemRepository;
import com.youchain.basicdata.repository.PointRepository;
import com.youchain.basicdata.service.ItemService;
import com.youchain.basicdata.service.PointService;
import com.youchain.basicdata.service.StockService;
@ -40,7 +41,7 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor
@Slf4j
public class MesServiceImpl implements MesService {
private final PointRepository pointRepository;
private final PickRepository pickRepository;
private final PickDetailRepository pickDetailRepository;
private final ItemRepository itemRepository;
@ -129,82 +130,55 @@ public class MesServiceImpl implements MesService {
@Override
@Transactional(rollbackFor = Exception.class)
public void itemCall(String gdNo, String itemCode, String station, String pointCode) {
public String itemCall(String gdNo, String itemCode, String station, String pointCode) {
Pick pick = pickRepository.findByPick(gdNo, itemCode, station);
if (pick == null) {
throw new BadRequestException(gdNo + ":" + itemCode + ":" + station + "工单不存在，叫料失败!");
return gdNo + ":" + itemCode + ":" + station + "工单WMS不存在，叫料失败!";
}
if (BizStatus.OPEN.equals(pick.getStatus())) {
throw new BadRequestException(gdNo + "工单未备料完成，叫料失败!");
}
Point point = pointService.queryPoint(pointCode, null, null, null);
if (point == null) {
throw new BadRequestException(pointCode + "点位不存在或已失效!");
}
pick.setIsCall(true);
if (pick.getCallPoint() == null || pick.getCallPoint().length() <= 0) {
pick.setCallPoint(pointCode);
} else if (!pointCode.equals(pick.getCallPoint())) {
} else {
pick.setCallPoint(pick.getCallPoint() + "," + pointCode);
}
pick.setIsCall(true);
pickRepository.save(pick);
taskService.callJlTask(pick);
return "叫料成功!";
}
@Override
@Transactional(rollbackFor = Exception.class)
public void bigItemCall(String gdNo, String completeCode, String station, String pointCode) {
public String bigItemCall(String gdNo, String completeCode, String station, String pointCode) {
Pick pick = pickRepository.findByPick(gdNo, completeCode, station);
if (pick == null) {
throw new BadRequestException(gdNo + ":" + completeCode + ":" + station + "工单不存在，叫料失败!");
return gdNo + ":" + completeCode + ":" + station + "工单WMS不存在，叫料失败!";
}
if (BizStatus.OPEN.equals(pick.getStatus())) {
throw new BadRequestException(gdNo + "工单未备料完成，叫料失败!");
}
Point point = pointService.queryPoint(pointCode, null, null, null);
if (point == null) {
throw new BadRequestException(pointCode + "点位不存在或已失效!");
}
pick.setIsCall(true);
if (pick.getCallPoint() == null || pick.getCallPoint().length() <= 0) {
pick.setCallPoint(pointCode);
} else if (!pointCode.equals(pick.getCallPoint())) {
} else {
pick.setCallPoint(pick.getCallPoint() + "," + pointCode);
}
pick.setIsCall(true);
pickRepository.save(pick);
taskService.callJlTask(pick);
//taskService.callJlTask(pick);
return "叫料成功!";
}
@Override
@Transactional(rollbackFor = Exception.class)
public void performTransportTask(TransTask transTask) {
public String performTransportTask(TransTask transTask) {
switch (transTask.getTaskType()) {
case BizStatus.Cp_Off_Up:
moveCpOffUp(transTask.getPointCode());//呼叫空货架
break;
return moveCpOffUp(transTask.getPointCode());//呼叫空货架
case BizStatus.Cp_Off_Line:
moveCpOffLine(transTask);//送满货架
break;
return moveCpOffLine(transTask);//送满货架
case BizStatus.Fx_Off_Line:
moveFxOffLine(transTask);//返修呼叫空托盘、返修下线
break;
return moveFxOffLine(transTask);//返修呼叫空托盘、返修下线
case BizStatus.Fx_Back:
moveFxBack(transTask);//返修载具送回
break;
return moveFxBack(transTask);//返修载具送回
case BizStatus.JL_Back:
moveJLBack(transTask);//叫料返空
break;
return moveJLBack(transTask);//叫料返空
default:
throw new BadRequestException("任务类型错误!");
return "任务类型错误!";
}
}
@ -271,90 +245,109 @@ public class MesServiceImpl implements MesService {
return pickDetail;
}
private void moveCpOffUp(String pointCode) {
// 从成品入库缓存区查询空车；没有在从成品入库区查询空车；
private String moveCpOffUp(String pointCode) {
//终点
Point endPoint = pointRepository.findByCode(pointCode);
// 查询空车
List<Stock> emptyStockList = getEmptyStockList();
if (emptyStockList.isEmpty()) {
// 没有空车的处理逻辑
if (!isEndPointAvailable(endPoint.getCode(), BizStatus.Cp_Off_Up, "RACK_MOVE")) {
return pointCode + "点位有任务，请稍后再试!";
}
// 生成agv任务进行等待
agvTaskService.createAgvTask(BizStatus.Cp_Off_Up, null, null, endPoint.getCode(), "RACK_MOVE");
pointService.usedPoint(endPoint);
return "成品入库区、成品入库缓存区都没有空车,请稍后再试!";
}
//选择空车
Stock emptyStock = emptyStockList.get(0);
Point srcPoint = emptyStock.getPoint();
// 验证终点是否有任务
if (!isEndPointAvailable(endPoint.getCode(), BizStatus.Cp_Off_Up, "RACK_MOVE")) {
return pointCode + "点位有任务，请稍后再试!";
}
//创建Agv任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Up, emptyStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
// 更新点位状态
pointService.usedPoint(endPoint);
return "呼叫成功";
}
/**
* 从成品入库缓存区或成品入库区查询空车
*
* @return 空车列表
*/
private List<Stock> getEmptyStockList() {
List<Stock> emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKHCQ, BaseStatus.FREE);
if (emptyStockList.isEmpty()) {
emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKQ, BaseStatus.FREE);
if (emptyStockList.isEmpty()) {
throw new BadRequestException("成品入库区、成品入库缓存区都没有空车,请稍后再试!");
}
}
//容器
Stock emptyStock = emptyStockList.get(0);
//起点
Point srcPoint = emptyStock.getPoint();
//终点
Point endPoint = pointService.validatePoint(pointCode);
//验证终点是否有任务
if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Up, "RACK_MOVE")) {
// 直接在条件判断为false时抛出异常，表示该点位有任务
throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
}
//创建Agv任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Up, emptyStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
// 更新点位状态
pointService.usedPoint(endPoint);
//下发任务
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
return emptyStockList;
}
private void moveCpOffLine(TransTask transTask) {
//查询下线缓存区是否有满货架；
List<Stock> fullStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPXXHC, BaseStatus.USED);
if (!fullStockList.isEmpty()) {
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
if (!endPointList.isEmpty()) {
//容器
Stock fullStock = fullStockList.get(0);
//起点
Point srcPoint = fullStock.getPoint();
//终点
Point endPoint = endPointList.get(0);
//验证终点是否有任务
if (agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
//创建Agv任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, fullStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
synchronized (endPoint) {
// 更新点位状态
pointService.usedPoint(endPoint);
//占用容器
stockService.usedStock(fullStock, srcPoint, BaseStatus.USED);
/**
* 验证终点是否有任务
*
* @param endPointCode 终点点位代码
* @return 终点是否可用
*/
private boolean isEndPointAvailable(String endPointCode, String type, String jobType) {
return agvTaskService.findByEndSlotCode(endPointCode, type, jobType);
}
//下发任务
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
}
}
/**
* 验证起点是否有任务
*
* @param startSlotCode 终点点位代码
* @return 终点是否可用
*/
private boolean isSrcPointAvailable(String startSlotCode, String type, String jobType) {
return agvTaskService.findByStartSlotCode(startSlotCode, type, jobType);
}
private String moveCpOffLine(TransTask transTask) {
Point srcPoint = pointRepository.findByCode(transTask.getPointCode());
if (srcPoint == null) {
return transTask.getPointCode() + "点位不存在!";
}
// 处理下线缓存区有满货架的情况
String result = handleFullStockInCache(srcPoint);
if (result != null) {
return result;
}
//下线缓存区没有满货架，直接下发当前任务
Point srcPoint = pointService.validatePoint(transTask.getPointCode());
//容器
Stock stock = stockService.findByPointCode(srcPoint.getCode());
if (stock == null) {
throw new BadRequestException(srcPoint.getCode() + "点位没有货架!");
// 查找可用的终点点位
Point endPoint = findAvailableEndPoint();
if (endPoint == null) {
// 没有可用终点点位的处理逻辑
if (!isSrcPointAvailable(srcPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
return srcPoint.getCode() + "点位有任务，请稍后再试!";
}
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
if (endPointList.isEmpty()) {
endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPXXHC);
if (endPointList.isEmpty()) {
throw new BadRequestException("成品入库区和成品下线缓存区都没有空闲点位!");
// 生成等待任务
agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, stock, srcPoint.getCode(), null, "RACK_MOVE");
return "成品入库区和成品下线缓存区都没有空闲点位,请稍后再试!";
}
}
//终点
Point endPoint = endPointList.get(0);
// 验证终点是否有任务
if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
// 直接在条件判断为false时抛出异常，表示该点位有任务
throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
if (!isEndPointAvailable(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
return transTask.getPointCode() + "点位有任务，请稍后再试!";
}
// 创建Agv任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
// 同步更新终点点位状态和占用容器
synchronized (endPoint) {
// 更新点位状态
pointService.usedPoint(endPoint);
@ -362,11 +355,66 @@ public class MesServiceImpl implements MesService {
stockService.usedStock(stock, srcPoint, BaseStatus.USED);
}
//下发任务
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
return "呼叫成功";
}
private void moveFxOffLine(TransTask transTask) {
/**
* 查找可用的终点点位，优先从成品入库区查找，若没有则从成品下线缓存区查找
*
* @return 可用的终点点位，如果没有则返回null
*/
private Point findAvailableEndPoint() {
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
if (endPointList.isEmpty()) {
endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPXXHC);
}
return endPointList.isEmpty() ? null : endPointList.get(0);
}
/**
* 处理下线缓存区有满货架的情况
*
* @param srcPoint 源点位
* @return 处理结果信息，如果为空则表示继续后续流程
*/
private String handleFullStockInCache(Point srcPoint) {
// 查询下线缓存区是否有满货架
List<Stock> fullStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPXXHC, BaseStatus.USED);
if (!fullStockList.isEmpty()) {
// 取第一个满货架容器
Stock fullStock = fullStockList.get(0);
// 查找成品入库区的可用终点点位
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
if (!endPointList.isEmpty()) {
// 取第一个可用终点点位
Point endPoint = endPointList.get(0);
// 验证终点是否有任务
if (agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
// 创建Agv任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, fullStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
// 同步更新终点点位状态和占用容器
synchronized (endPoint) {
// 更新点位状态
pointService.usedPoint(endPoint);
// 占用容器
stockService.usedStock(fullStock, srcPoint, BaseStatus.USED);
}
}
} else {
// 没有空车的处理逻辑
if (!isSrcPointAvailable(fullStock.getPoint().getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
return fullStock.getPoint().getCode() + "点位有任务，请稍后再试!";
}
// 生成agv任务进行等待
agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, fullStock, fullStock.getCode(), null, "RACK_MOVE");
return "成品入库区和成品下线缓存区都没有空闲点位,请稍后再试!";
}
}
return null;
}
private String moveFxOffLine(TransTask transTask) {
//返修上线起点
String srcPointCode = transTask.getPointCode();
//终点
@ -381,63 +429,78 @@ public class MesServiceImpl implements MesService {
} else if (gtLineMap.isOfflinePoint(srcPointCode)) {
dstPointCode = gtLineMap.getValueByKey(srcPointCode);
} else {
throw new BadRequestException(srcPointCode + "点位不存在,请核实");
return srcPointCode + "点位不存在,请核实!";
}
// 验证终点是否有任务
if (!agvTaskService.findByEndSlotCode(dstPointCode, BizStatus.Fx_Off_Line, "ROLLER_MOVE")) {
throw new BadRequestException(dstPointCode + "点位有任务，请稍后再试!");
if (!isEndPointAvailable(dstPointCode, BizStatus.Fx_Off_Line, "ROLLER_MOVE")) {
return dstPointCode + "点位有任务，请稍后再试!";
}
// 生成任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Fx_Off_Line, null, srcPointCode, dstPointCode, "ROLLER_MOVE");
// 下发任务
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskGtJson(agvTask));
return "呼叫成功";
}
private void moveFxBack(TransTask transTask) {
private String moveFxBack(TransTask transTask) {
String srcPointCode = transTask.getPointCode();
if (!"FX001".equals(srcPointCode)) {
throw new BadRequestException("返修点位不正确,请核实");
return "返修点位不正确,请核实";
}
//根据状态查询任务
List<AgvTask> agvTaskList = agvTaskService.findByStatus(BizStatus.ARRIVED);
if (agvTaskList.isEmpty()) {
throw new BadRequestException("任务还未达到FX001返修点，请稍后再试!");
return "AGV还未达到FX001返修点，请稍后再试!";
}
AgvTask agvTask = agvTaskList.get(0);
//任务放行
kmReService.sendAgvTaskToContainer(UrlApi.operationFeedback(), kmReService.operationFeedbackJson(agvTask));
return "放行成功";
}
private void moveJLBack(TransTask transTask) {
private String moveJLBack(TransTask transTask) {
//起点
Point srcPoint = pointService.validatePoint(transTask.getPointCode());
Stock stock = stockService.findByPointCode(srcPoint.getCode());
if (stock == null) {
throw new BadRequestException(srcPoint.getCode() + "点位没有货架!");
Point srcPoint = pointRepository.findByCode(transTask.getPointCode());
if (srcPoint == null) {
return transTask.getPointCode() + "点位不存在!";
}
//容器
Stock stock = stockService.findByPointCode(srcPoint.getCode());
String dstAreaCode = AreaNameDic.XJJLQ.equals(srcPoint.getArea().getName()) ? AreaNameDic.XJFBCQ : AreaNameDic.DJFBCQ;
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, dstAreaCode);
if (endPointList.isEmpty()) {
throw new BadRequestException(dstAreaCode.equals(AreaNameDic.XJFBCQ) ? "小件翻包存储区" : "大件翻包存储区" + "没有空闲点位!");
// 没有空车的处理逻辑
if (!isSrcPointAvailable(srcPoint.getCode(), BizStatus.CALL_RETURN, "RACK_MOVE")) {
return srcPoint.getCode() + "点位有任务，请稍后再试!";
}
//生成agv任务进行等待
agvTaskService.createAgvTask(BizStatus.CALL_RETURN, stock, srcPoint.getCode(), null, "RACK_MOVE");
return dstAreaCode.equals(AreaNameDic.XJFBCQ) ? "小件翻包存储区" : "大件翻包存储区" + "没有空闲点位!";
}
Point endPoint = endPointList.get(0);
// 验证终点是否有任务
if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.CALL_RETURN, "RACK_MOVE")) {
throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
if (!isEndPointAvailable(endPoint.getCode(), BizStatus.CALL_RETURN, "RACK_MOVE")) {
return endPoint.getCode() + "点位有任务，请稍后再试!";
}
// 生成任务
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.CALL_RETURN, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
synchronized (endPoint) {
// 更新点位状态
pointService.usedPoint(endPoint);
//占用容器
stockService.usedStock(stock, srcPoint, BaseStatus.USED);
}
return "呼叫成功";
}
}

62
youchain-system/src/main/java/com/youchain/businessdata/service/impl/TaskServiceImpl.java
View File

@ -141,8 +141,8 @@ public class TaskServiceImpl implements TaskService {
}
@Override
public List<Task> findByPickNotAllTask(Long pickId) {
return taskRepository.findByPickNotAllTask(pickId);
public List<Task> findByPickNotAllTask() {
return taskRepository.findByPickNotAllTask();
}
@Override
@ -238,9 +238,9 @@ public class TaskServiceImpl implements TaskService {
@Override
@Transactional(rollbackFor = Exception.class)
public void materialPick(Pick pick) {
public void materialPick() {
AgvTask agvTask = null;
List<Task> taskList = this.findByPickNotAllTask(pick.getId());
List<Task> taskList = this.findByPickNotAllTask();
for (Task task : taskList) {
/*生成搬运任务*/
List<AgvTask> agvTaskList = agvTaskService.findRepeat(task.getSrcStockCode(), task.getSrcPointCode(), task.getDstPointCode());
@ -257,11 +257,6 @@ public class TaskServiceImpl implements TaskService {
task.setTaskStatus(agvTask.getStatus());
taskRepository.save(task);
}
/*更新出库单状态*//*
pick.setStatus(BizStatus.PICKUP);
pickService.update(pick);*/
}
@Override
@ -301,47 +296,38 @@ public class TaskServiceImpl implements TaskService {
@Override
@Transactional(rollbackFor = Exception.class)
public void callJlTask(Pick pick) {
if (pick.getStock() == null) {
throw new BadRequestException(pick.getGdCode() + "工单未翻包拣货!");
}
if (pick.getCallPoint() == null) {
throw new BadRequestException(pick.getGdCode() + "工单没有叫料请求!");
}
//绑定任务
List<Task> taskList = this.findByPickAllTask(pick.getId());
if (taskList.isEmpty()) {
throw new BadRequestException(pick.getGdCode() + "没有翻包拣货任务!");
return;
}
//起点
String[] stocks = pick.getStock().split(",");
String stockCode = stocks[stocks.length - 1];
Stock stock = stockService.validateStock(stockCode);
Point srcPoint = stock.getPoint();
//终点
String[] points = pick.getCallPoint().split(",");
String endPointCode = points[points.length - 1];
Point endPoint = pointService.queryPoint(endPointCode, null, null, null);
/* AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.CALL_PICK, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
agvTask.setLineSlotCode(pick.getCode());
agvTaskService.update(agvTask);*/
AgvTask agvTask = null;
for (Task task : taskList) {
List<AgvTask> agvTasks = agvTaskService.findRepeat(task.getDstStockCode(), task.getDstPointCode(), endPoint.getCode());
if (agvTasks.isEmpty()) {
//创建任务
if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.CALL_PICK, "RACK_MOVE")) {
throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
}
AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.CALL_PICK, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
agvTask = agvTaskService.createAgvTask(BizStatus.JL_Back, task.getDstStock(), task.getDstPointCode(), endPoint.getCode(), "RACK_MOVE");
agvTask.setLineSlotCode(pick.getCode());
agvTaskService.update(agvTask);
for (Task task : taskList) {
} else {
agvTask = agvTasks.get(0);
}
task.setCallAgvTaskId(agvTask.getId());
taskRepository.save(task);
}
//起点占用
pointService.usedPoint(srcPoint);
//终点占用
pointService.usedPoint(endPoint);
}
@ -619,16 +605,6 @@ public class TaskServiceImpl implements TaskService {
pickDetail.setPickedQty(pickDetail.getPickedQty() + moveQty);
pickDetailService.update(pickDetail);
Pick pick = pickDetail.getPick();
if (pick.getStock() == null || pick.getStock().length() <= 0) {
pick.setStock(dstStock.getCode());
} else if (!dstStock.getCode().equals(pick.getStock())) {
pick.setStock(pick.getStock() + "," + dstStock.getCode());
}
pickService.update(pick);
//容器占用
stockService.usedStock(dstStock, dstStock.getPoint(), BaseStatus.USED);

75
youchain-system/src/main/java/com/youchain/modules/quartz/task/blTask.java 100644
View File

@ -0,0 +1,75 @@
package com.youchain.modules.quartz.task;
import com.youchain.basicdata.domain.Point;
import com.youchain.basicdata.domain.Stock;
import com.youchain.basicdata.service.StockService;
import com.youchain.businessdata.domain.AgvTask;
import com.youchain.businessdata.service.AgvTaskService;
import com.youchain.businessdata.service.KMReService;
import com.youchain.businessdata.service.PickService;
import com.youchain.businessdata.service.TaskService;
import com.youchain.exception.BadRequestException;
import com.youchain.utils.BizStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 备料任务
*/
@Slf4j
@Service
public class blTask {
@Autowired
public StockService stockService;
@Autowired
public PickService pickService;
@Autowired
public TaskService taskService;
@Autowired
public AgvTaskService agvTaskService;
@Autowired
public KMReService kmReService;
// 定义异常信息常量
private static final String NO_EMPTY_SHELVES_ERROR_MSG = "没有备料任务!";
// 定义一个对象作为锁
private final Object lock = new Object();
/**
* 轮询下发备料任务、叫料任务、
*/
public void sendAgvBl() {
List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.PICK);
if (agvTaskList.isEmpty()) {
throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
}
synchronized (lock) {
for (AgvTask agvTask : agvTaskList) {
processAgvTask(agvTask);
}
}
}
private void processAgvTask(AgvTask agvTask) {
//目标点没有托盘继续下发下一个任务
String endSlotCode = agvTask.getEndSlotCode();
Stock stock = stockService.findByPointCode(endSlotCode);
if (stock == null) {
boolean isTaskFound = agvTaskService.findByCcEndSlotCode(endSlotCode, BizStatus.PICK, "FORKLIFT_MOVE");
if (isTaskFound) {
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskCcJson(agvTask));
}
}
}
}

96
youchain-system/src/main/java/com/youchain/modules/quartz/task/cpLineTask.java 100644
View File

@ -0,0 +1,96 @@
package com.youchain.modules.quartz.task;
import com.youchain.basicdata.domain.Point;
import com.youchain.basicdata.service.PointService;
import com.youchain.basicdata.service.StockService;
import com.youchain.businessdata.domain.AgvTask;
import com.youchain.businessdata.service.AgvTaskService;
import com.youchain.businessdata.service.KMReService;
import com.youchain.exception.BadRequestException;
import com.youchain.utils.AreaNameDic;
import com.youchain.utils.BaseStatus;
import com.youchain.utils.BizStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 成品下线任务
*/
@Slf4j
@Service
public class cpLineTask {
@Autowired
public StockService stockService;
@Autowired
private PointService pointService;
@Autowired
public AgvTaskService agvTaskService;
@Autowired
public KMReService kmReService;
// 定义异常信息常量
private static final String NO_EMPTY_SHELVES_ERROR_MSG = "成品入库区和成品入库缓存区都没有空闲点位，请及时处理!";
// 定义一个对象作为锁
private final Object lock = new Object();
public void sendAgvCpOffLine() {
// 使用同步块确保线程安全
synchronized (lock) {
// 获取处于特定业务状态的AGV任务列表
List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.Cp_Off_Line);
// 如果任务列表为空，直接返回，避免不必要的处理
if (agvTaskList.isEmpty()) {
return;
}
// 遍历AGV任务列表
for (AgvTask agvTask : agvTaskList) {
processAgvTask(agvTask);
}
}
}
private void processAgvTask(AgvTask agvTask) {
if (agvTask.getEndSlotCode() != null) {
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
} else {
// 查找可用的结束点
Point endPoint = findAvailableEndPoint();
if (endPoint != null) {
updateAgvTaskWithEndPoint(agvTask, endPoint);
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
} else {
// 若未找到可用结束点，抛出异常
throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
}
}
}
private void updateAgvTaskWithEndPoint(AgvTask agvTask, Point endPoint) {
// 设置任务的结束插槽代码
agvTask.setEndSlotCode(endPoint.getCode());
// 更新AGV任务信息
agvTaskService.update(agvTask);
}
/**
* 查找可用的终点点位，优先从成品入库区查找，若没有则从成品下线缓存区查找
*
* @return 可用的终点点位，如果没有则返回null
*/
private Point findAvailableEndPoint() {
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
if (endPointList.isEmpty()) {
endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPXXHC);
}
return endPointList.isEmpty() ? null : endPointList.get(0);
}
}

91
youchain-system/src/main/java/com/youchain/modules/quartz/task/cpUpTask.java 100644
View File

@ -0,0 +1,91 @@
package com.youchain.modules.quartz.task;
import com.youchain.basicdata.domain.Stock;
import com.youchain.basicdata.service.StockService;
import com.youchain.businessdata.domain.AgvTask;
import com.youchain.businessdata.service.AgvTaskService;
import com.youchain.businessdata.service.KMReService;
import com.youchain.exception.BadRequestException;
import com.youchain.utils.AreaNameDic;
import com.youchain.utils.BaseStatus;
import com.youchain.utils.BizStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 成品上线任务
*/
@Slf4j
@Service
public class cpUpTask {
@Autowired
public StockService stockService;
@Autowired
public AgvTaskService agvTaskService;
@Autowired
public KMReService kmReService;
// 定义异常信息常量
private static final String NO_EMPTY_SHELVES_ERROR_MSG = "成品入库区和成品入库缓存区都没有空货架，请及时解绑容器!";
private final Object lock = new Object();
/**
* 轮询下发成品上线任务
*/
public void sendAgvCpOffUp() {
synchronized (lock) {
List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.Cp_Off_Up);
if (agvTaskList.isEmpty()) {
return;
}
// 遍历AGV任务列表
for (AgvTask agvTask : agvTaskList) {
processAgvTask(agvTask);
}
}
}
private List<Stock> getEmptyStockList() {
List<Stock> emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKHCQ, BaseStatus.FREE);
if (emptyStockList.isEmpty()) {
emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKQ, BaseStatus.FREE);
}
return emptyStockList;
}
private void processAgvTask(AgvTask agvTask) {
if (agvTask.getStockCode() != null && agvTask.getStartSlotCode() != null) {
//直接下发
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
} else {
//排队任务 查询成品入库区是否有空车
List<Stock> stocks = getEmptyStockList();
if (!stocks.isEmpty()) {
// 获取第一个空库存
Stock stock = stocks.get(0);
// 更新AGV任务的库存代码和起始插槽代码
updateAgvTask(agvTask, stock);
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
} else {
// 若没有空货架，抛出异常
throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
}
}
}
private void updateAgvTask(AgvTask agvTask, Stock stock) {
// 设置AGV任务的库存代码
agvTask.setStockCode(stock.getCode());
// 设置AGV任务的起始插槽代码
agvTask.setStartSlotCode(stock.getPoint() == null ? null : stock.getPoint().getCode());
// 更新AGV任务
agvTaskService.update(agvTask);
}
}

103
youchain-system/src/main/java/com/youchain/modules/quartz/task/jlBackTask.java 100644
View File

@ -0,0 +1,103 @@
package com.youchain.modules.quartz.task;
import com.youchain.basicdata.domain.Point;
import com.youchain.basicdata.domain.Stock;
import com.youchain.basicdata.repository.PointRepository;
import com.youchain.basicdata.service.PointService;
import com.youchain.basicdata.service.StockService;
import com.youchain.businessdata.domain.AgvTask;
import com.youchain.businessdata.service.AgvTaskService;
import com.youchain.businessdata.service.KMReService;
import com.youchain.exception.BadRequestException;
import com.youchain.utils.AreaNameDic;
import com.youchain.utils.BaseStatus;
import com.youchain.utils.BizStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 叫料返空任务
*/
@Slf4j
@Service
public class jlBackTask {
@Autowired
public StockService stockService;
@Autowired
private PointService pointService;
@Autowired
public AgvTaskService agvTaskService;
@Autowired
public KMReService kmReService;
// 定义异常信息常量
private static final String NO_EMPTY_SHELVES_ERROR_MSG = "区没有空闲点位，请及时处理!";
// 定义一个对象作为锁
private final Object lock = new Object();
public void sendAgvJlBack() {
// 使用同步块确保线程安全
synchronized (lock) {
// 获取处于特定业务状态的AGV任务列表
List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.JL_Back);
// 如果任务列表为空，直接返回，避免不必要的处理
if (agvTaskList.isEmpty()) {
return;
}
// 遍历AGV任务列表
for (AgvTask agvTask : agvTaskList) {
processAgvTask(agvTask);
}
}
}
private void processAgvTask(AgvTask agvTask) {
if (agvTask.getEndSlotCode() != null) {
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
} else {
// 查找可用的结束点
String areaName = getAreaName(agvTask.getStartSlotCode());
Point endPoint = findAvailableEndPoint(areaName);
if (endPoint != null) {
updateAgvTaskWithEndPoint(agvTask, endPoint);
} else {
// 若未找到可用结束点，抛出异常
throw new BadRequestException(areaName+NO_EMPTY_SHELVES_ERROR_MSG);
}
}
}
private void updateAgvTaskWithEndPoint(AgvTask agvTask, Point endPoint) {
// 设置任务的结束插槽代码
agvTask.setEndSlotCode(endPoint.getCode());
// 更新AGV任务信息
agvTaskService.update(agvTask);
}
private String getAreaName(String pointCode) {
Point srcPoint = pointService.validatePoint(pointCode);
Stock stock = stockService.findByPointCode(srcPoint.getCode());
String areaName = AreaNameDic.XJJLQ.equals(srcPoint.getArea().getName()) ? AreaNameDic.XJFBCQ : AreaNameDic.DJFBCQ;
return areaName;
}
/**
* 查找可用的终点点位，优先从成品入库区查找，若没有则从成品下线缓存区查找
*
* @return 可用的终点点位，如果没有则返回null
*/
private Point findAvailableEndPoint(String areaName) {
String dstAreaCode = AreaNameDic.XJJLQ.equals(areaName) ? AreaNameDic.XJFBCQ : AreaNameDic.DJFBCQ;
List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, dstAreaCode);
return endPointList.isEmpty() ? null : endPointList.get(0);
}
}

67
youchain-system/src/main/java/com/youchain/modules/quartz/task/jlTask.java 100644
View File

@ -0,0 +1,67 @@
package com.youchain.modules.quartz.task;
import com.youchain.basicdata.domain.Point;
import com.youchain.basicdata.domain.Stock;
import com.youchain.basicdata.service.StockService;
import com.youchain.businessdata.domain.AgvTask;
import com.youchain.businessdata.service.AgvTaskService;
import com.youchain.businessdata.service.KMReService;
import com.youchain.businessdata.service.PickService;
import com.youchain.businessdata.service.TaskService;
import com.youchain.exception.BadRequestException;
import com.youchain.utils.BizStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 备料任务
*/
@Slf4j
@Service
public class jlTask {
@Autowired
public StockService stockService;
@Autowired
public PickService pickService;
@Autowired
public TaskService taskService;
@Autowired
public AgvTaskService agvTaskService;
@Autowired
public KMReService kmReService;
// 定义异常信息常量
private static final String NO_EMPTY_SHELVES_ERROR_MSG = "没有叫料任务!";
// 定义一个对象作为锁
private final Object lock = new Object();
/**
* 下发叫料任务
*/
public void sendAgvJl() {
List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.CALL_PICK);
if (agvTaskList.isEmpty()) {
throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
}
synchronized (lock) {
for (AgvTask agvTask : agvTaskList) {
processAgvTask(agvTask);
}
}
}
private void processAgvTask(AgvTask agvTask) {
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
}
}

62
youchain-system/src/main/java/com/youchain/modules/quartz/task/pickTask.java
View File

@ -48,7 +48,7 @@ public class pickTask {
* 分配出库单
*/
public void allocatePick() {
List<String> statuses = Arrays.asList(BizStatus.OPEN, BizStatus.ASSIGN);
List<String> statuses = Arrays.asList(BizStatus.OPEN, BizStatus.ASSIGN, BizStatus.PICKUP);
List<Pick> pickList = pickService.findByPickStatus(statuses, null);
if (pickList.isEmpty()) {
throw new BadRequestException("无待分配的成品出库单,分配失败!");
@ -59,31 +59,18 @@ public class pickTask {
}
}
//生成备料任务
taskService.materialPick();
}
/**
* 轮询已分配的出库单，生成备料任务
* 生成叫料任务
*/
public void pickAgvTask() {
/*查询分配完成的出库单*/
List<String> statuses = Arrays.asList(BizStatus.ASSIGN, BizStatus.ALLOCATE);
List<Pick> pickList = pickService.findByPickStatus(statuses, null);
if (pickList.isEmpty()) {
throw new BadRequestException("无已分配的出库单,下发任务失败!");
}
for (Pick pick : pickList) {
synchronized (pick) {
taskService.materialPick(pick);
}
}
}
/**
* 生成叫料搬运任务
*/
public void callJlTask() {
/*查询拣货完成完成的出库单*/
public void createJlTask() {
/* *//*查询拣货完成完成的出库单*//*
List<String> statuses = Arrays.asList(BizStatus.PICKUP, BizStatus.PICK_ALL);
List<Pick> pickList = pickService.findByPickStatus(statuses, true);
if (pickList.isEmpty()) {
@ -93,36 +80,7 @@ public class pickTask {
synchronized (pick) {
taskService.callJlTask(pick);
}
}
}
/**
* 轮询下发备料任务、叫料任务、叫料返库任务
*/
public void sendTaskBlAndJl() {
List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask();
if (agvTaskList.isEmpty()) {
throw new BadRequestException("无备料任务或无叫料任务!");
}
for (AgvTask agvTask : agvTaskList) {
synchronized (agvTask) {
if (BizStatus.PICK.equals(agvTask.getType())) {
//目标点没有托盘继续下发下一个任务
String endSlotCode = agvTask.getEndSlotCode();
Stock stock = stockService.findByPointCode(endSlotCode);
if (stock == null) {
boolean isTaskFound = agvTaskService.findByCcEndSlotCode(endSlotCode, BizStatus.PICK, "FORKLIFT_MOVE");
if (isTaskFound) {
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskCcJson(agvTask));
}
}
} else {
kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
}
}
}
}*/
}
}

2
youchain-system/src/main/java/com/youchain/utils/BizStatus.java
View File

@ -142,7 +142,7 @@ public interface BizStatus {
String Fx_Back = "Fx_Back";
/**
* 任务类型-返修载具送回
* 任务类型-叫料返空
*/
String JL_Back = "JL_Back";