package com.zy.asrs.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.core.common.Cools;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.mapper.WaitPakinMapper;
|
import com.zy.asrs.mapper.WrkMastMapper;
|
import com.zy.asrs.service.*;
|
import com.zy.common.model.StartupDto;
|
import com.zy.core.cache.MessageQueue;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.*;
|
import com.zy.core.model.CrnSlave;
|
import com.zy.core.model.DevpSlave;
|
import com.zy.core.model.Task;
|
import com.zy.core.model.command.CrnCommand;
|
import com.zy.core.model.protocol.CrnProtocol;
|
import com.zy.core.model.protocol.StaProtocol;
|
import com.zy.core.properties.SlaveProperties;
|
import com.zy.core.thread.BarcodeThread;
|
import com.zy.core.thread.CrnThread;
|
import com.zy.core.thread.DevpThread;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.Date;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
/**
|
* Created by vincent on 2020/8/6
|
*/
|
@Slf4j
|
@Service("mainService")
|
public class MainServiceImpl {
|
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private SlaveProperties slaveProperties;
|
@Autowired
|
private WrkMastMapper wrkMastMapper;
|
@Autowired
|
private WrkDetlService wrkDetlService;
|
@Autowired
|
private WaitPakinMapper waitPakinMapper;
|
@Autowired
|
private LocMastService locMastService;
|
@Autowired
|
private StaDescService staDescService;
|
@Autowired
|
private BasCrnpService basCrnpService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private JdbcTemplate jdbcTemplate;
|
|
/**
|
* 入库站，根据条码扫描生成入库工作档，工作状态 2
|
*/
|
@Transactional
|
public void generateStoreWrkFile() {
|
// 根据输送线plc遍历
|
for (DevpSlave devp : slaveProperties.getDevp()) {
|
// 遍历入库口
|
for (DevpSlave.Sta inSta : devp.getInSta()) {
|
// 获取条码
|
BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
|
String barcode = barcodeThread.getBarcode();
|
// 获取入库站信息
|
DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
|
StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
|
// 判断是否满足入库条件
|
if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInreq1()
|
&& !staProtocol.isEmptyMk() && staProtocol.isInreq1() && staProtocol.getWorkNo() ==0
|
&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {
|
// 判断重复工作档
|
WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
|
if (wrkMast != null) {
|
log.warn("工作档中已存在该站状态为1的数据,工作号-{}", wrkMast.getWrkNo());
|
continue;
|
}
|
// 获取入库通知档
|
List<WaitPakin> waitPakins = waitPakinMapper.selectList(new EntityWrapper<WaitPakin>().eq("barcode", barcode));
|
// 工作号
|
int workNo = commonService.getWorkNo(0);
|
// 检索库位
|
List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
|
StartupDto startupDto = commonService.getLocNo(1, 1, inSta.getStaNo(), matNos);
|
String locNo = startupDto.getLocNo();
|
if (!waitPakins.isEmpty()) {
|
// 插入工作明细档
|
wrkDetlService.createWorkDetail(workNo, waitPakins, barcode);
|
} else {
|
log.warn("无此入库条码数据---{}", barcode);
|
continue;
|
}
|
|
// 插入工作主档
|
wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
|
wrkMast.setIoType(1); // 入出库状态：1.入库
|
wrkMast.setIoPri(10D); // 优先级：10
|
wrkMast.setCrnNo(startupDto.getCrnNo());
|
wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
|
wrkMast.setStaNo(startupDto.getStaNo());
|
wrkMast.setLocNo(startupDto.getLocNo());
|
wrkMast.setBarcode(barcode); // 托盘码
|
wrkMast.setFullPlt("Y"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("N"); // 空板
|
wrkMast.setLinkMis("N");
|
// wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeTime(new Date());
|
wrkMast.setModiTime(new Date());
|
Integer insert = wrkMastMapper.insert(wrkMast);
|
if (insert == 0) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 更新目标库位状态
|
LocMast locMast = locMastService.selectById(startupDto.getLocNo());
|
locMast.setLocSts("S"); // S.入库预约
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)){
|
throw new CoolException("改变库位状态失败");
|
}
|
|
// 更新站点信息 且 下发plc命令
|
barcodeThread.setBarcode("");
|
staProtocol.setWorkNo(workNo);
|
staProtocol.setStaNo(startupDto.getStaNo());
|
staProtocol.setPakMk(false);
|
staProtocol.setInreq1(false);
|
boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
|
if (!result) {
|
throw new CoolException("更新plc站点信息失败");
|
}
|
|
}
|
|
|
}
|
}
|
|
}
|
|
|
/**
|
* 拣料、并板、盘点再入库
|
*/
|
public void stnToCrnStnPick(){
|
for (DevpSlave devp : slaveProperties.getDevp()) {
|
// 遍历拣料入库口
|
for (DevpSlave.Sta pickSta : devp.getPickSta()) {
|
// 获取拣料入库站信息
|
DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
|
StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
|
|
if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInreq1()
|
&& staProtocol.getWorkNo() > 0 && staProtocol.isPakMk()){
|
WrkMast wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
|
if (wrkMast == null) {
|
// 无拣料数据
|
continue;
|
}
|
if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 1070)
|
|| Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
|
continue;
|
}
|
// 保存工作明细档历史档
|
if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
|
throw new CoolException("保存工作明细档历史档失败");
|
}
|
// 保存工作主档历史档
|
if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
|
throw new CoolException("保存工作主档历史档失败");
|
}
|
// 获取目标站
|
Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
|
.eq("type_no", wrkMast.getIoType() - 50)
|
.eq("stn_no", wrkMast.getStaNo()) // 作业站点 = 拣料出库的目标站
|
.eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
|
StaDesc staDesc = staDescService.selectOne(wrapper);
|
if (Cools.isEmpty(staDesc)) {
|
throw new CoolException("入库路径不存在");
|
}
|
// 堆垛机站点(目标站)
|
Integer staNo = staDesc.getCrnStn();
|
// 更新工作档数据状态
|
wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
|
wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
|
wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
|
wrkMast.setStaNo(staNo); // 目标站
|
wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
|
wrkMast.setSourceLocNo(""); // 源库位清空
|
wrkMast.setModiTime(new Date());
|
if (wrkMastMapper.updateById(wrkMast) == 0) {
|
throw new CoolException("更新工作档数据状态失败");
|
}
|
// 修改库位状态 Q.拣料/盘点/并板再入库
|
LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
|
locMast.setLocSts("Q");
|
locMast.setModiTime(new Date());
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("修改库位状态失败");
|
}
|
|
// 更新站点信息 且 下发plc命令
|
staProtocol.setWorkNo(wrkMast.getWrkNo());
|
staProtocol.setStaNo(wrkMast.getStaNo());
|
staProtocol.setPakMk(false);
|
staProtocol.setInreq1(false);
|
boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
|
if (!result) {
|
throw new CoolException("更新plc站点信息失败");
|
}
|
|
}
|
|
}
|
|
}
|
}
|
|
/**
|
* 堆垛机站出库到出库站
|
*/
|
public void crnStnToOutStn() {
|
for (DevpSlave devp : slaveProperties.getDevp()) {
|
// 遍历拣料入库口
|
for (DevpSlave.Sta outSta : devp.getOutSta()) {
|
// 获取堆垛机出库站信息
|
DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
|
StaProtocol staProtocol = devpThread.getStation().get(outSta.getStaNo());
|
if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
|
// 查询工作档
|
WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId());
|
if (wrkMast == null) {
|
continue;
|
}
|
// 判断工作档条件
|
if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
|
continue;
|
}
|
// 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
|
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
|
CrnProtocol crnProtocol = crnThread.getCrnProtocol();
|
if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
|
// 移动中
|
continue;
|
}
|
// 更新工作档状态为14失败 todo:luxiaotao
|
if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
|
&& crnProtocol.statusType == CrnStatusType.IDLE
|
&& crnProtocol.forkPosType == CrnForkPosType.HOME) {
|
wrkMast.setWrkSts(14L);
|
wrkMast.setCrnEndTime(new Date());
|
if (wrkMastMapper.updateById(wrkMast) == 0) {
|
throw new CoolException("更新工作档的工作状态为14失败，工作号"+wrkMast.getWrkNo());
|
}
|
}
|
|
// 命令下发区 --------------------------------------------------------------------------
|
|
// 1.复位堆垛机 更新堆垛机信息 且 下发plc命令 todo:luxiaotao
|
crnProtocol.setStatus(CrnStatusType.IDLE);
|
crnProtocol.setTaskNo((short)0);
|
if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(4, crnProtocol))) {
|
throw new CoolException("更新堆垛机信息失败");
|
}
|
|
// 2.下发站点信息
|
staProtocol.setWorkNo(wrkMast.getWrkNo());
|
staProtocol.setStaNo(wrkMast.getStaNo());
|
if (!MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol))) {
|
throw new CoolException("更新plc站点信息失败");
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 入出库 ===>> 堆垛机站到库位 堆垛机入出库作业下发
|
*/
|
public void crnIoExecute(){
|
for (CrnSlave crn : slaveProperties.getCrn()) {
|
// 获取堆垛机信息
|
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
|
CrnProtocol crnProtocol = crnThread.getCrnProtocol();
|
BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
|
if (basCrnp == null) {
|
continue;
|
}
|
// 只有当堆垛机空闲 并且 无任务时才继续执行
|
if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0) {
|
// 如果最近一次是入库模式
|
if (crnProtocol.getLastIo().equals("I")) {
|
if (basCrnp.getInEnable().equals("Y")) {
|
this.crnStnToLoc(crn); // 入库
|
crnProtocol.setLastIo("O");
|
} else if (basCrnp.getOutEnable().equals("Y")) {
|
this.locToCrnStn(crn); // 出库
|
crnProtocol.setLastIo("I");
|
}
|
}
|
// 如果最近一次是出库模式
|
else if (crnProtocol.getLastIo().equals("O")) {
|
if (basCrnp.getOutEnable().equals("Y")) {
|
this.locToCrnStn(crn); // 出库
|
crnProtocol.setLastIo("I");
|
} else if (basCrnp.getInEnable().equals("Y")) {
|
this.crnStnToLoc(crn); // 入库
|
crnProtocol.setLastIo("O");
|
}
|
}
|
}
|
// 库位移转
|
this.locToLoc(crn);
|
}
|
}
|
|
/**
|
* 入库 ===>> 堆垛机站到库位
|
*/
|
private void crnStnToLoc(CrnSlave slave){
|
for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
|
boolean flag = false;
|
// 获取堆垛机入库站信息
|
DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
|
StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
|
// 查询站点详细信息
|
BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
|
if (staDetl == null) {
|
log.error("入库库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
|
continue;
|
}
|
if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staDetl.getCanining().equals("Y")) {
|
flag = true;
|
}
|
if (!flag) {
|
continue;
|
}
|
// 获取工作状态为2（设备上走）的入库工作档
|
WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo());
|
if(null == wrkMast) {
|
log.error("查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
|
continue;
|
}
|
// 获取库位信息
|
LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
|
if (locMast == null) {
|
log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
|
continue;
|
}
|
if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
|
log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
|
continue;
|
}
|
|
// 命令下发区 --------------------------------------------------------------------------
|
CrnCommand crnCommand = new CrnCommand();
|
crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
|
crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
|
crnCommand.setAckFinish((short) 0); // 任务完成确认位
|
crnCommand.setTaskMode(CrnTaskModeType.PAKIN); // 任务模式: 库位移转
|
crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排
|
crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列
|
crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层
|
crnCommand.setDestinationPosX(locMast.getRow1().shortValue()); // 目标库位排
|
crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
|
crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
|
if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
|
log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
|
} else {
|
// 修改工作档状态 2=>3 todo:luxiaotao
|
// Date now = new Date();
|
// wrkMast.setWrkSts(3L);
|
// wrkMast.setCrnStrTime(now);
|
// wrkMast.setModiTime(now);
|
}
|
}
|
}
|
|
/**
|
* 出库 ===>> 库位到堆垛机站
|
*/
|
private void locToCrnStn(CrnSlave slave){
|
for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
|
// 获取工作状态为11（生成出库ID）的出库工作档
|
WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId());
|
if (wrkMast == null) {
|
continue;
|
}
|
// 工作档状态判断
|
if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null){
|
log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
|
continue;
|
}
|
// 获取源库位信息
|
LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
|
if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
|
log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
|
continue;
|
}
|
// 获取堆垛机出库站信息
|
DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
|
StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
|
// 查询站点详细信息
|
BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
|
if (staDetl == null) {
|
log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
|
continue;
|
}
|
// 判断堆垛机出库站状态
|
if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting().equals("Y")
|
&& staProtocol.getWorkNo() == 0) {
|
// 命令下发区 --------------------------------------------------------------------------
|
CrnCommand crnCommand = new CrnCommand();
|
crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
|
crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
|
crnCommand.setAckFinish((short) 0); // 任务完成确认位
|
crnCommand.setTaskMode(CrnTaskModeType.PAKOUT); // 任务模式: 库位移转
|
crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排
|
crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列
|
crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层
|
crnCommand.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
|
crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
|
crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
|
if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
|
log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
|
}
|
}
|
}
|
}
|
|
/**
|
* 库位移转
|
*/
|
private void locToLoc(CrnSlave slave){
|
// 获取工作档信息
|
WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
|
if (null == wrkMast) {
|
return;
|
}
|
// 获取源库位信息
|
LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
|
if (null == sourceSta) {
|
log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
|
return;
|
}
|
// 源库位 库位状态判断
|
if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("S")) {
|
return;
|
}
|
// 获取目标库位信息
|
LocMast sta = locMastService.selectById(wrkMast.getLocNo());
|
if (null == sta) {
|
log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
|
return;
|
}
|
// 获取堆垛机信息 并 判断是否可入出
|
BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
|
if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
|
return;
|
}
|
// 命令下发区 --------------------------------------------------------------------------
|
CrnCommand crnCommand = new CrnCommand();
|
crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
|
crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
|
crnCommand.setAckFinish((short) 0); // 任务完成确认位
|
crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
|
crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排
|
crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列
|
crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层
|
crnCommand.setDestinationPosX(sta.getRow1().shortValue()); // 目标库位排
|
crnCommand.setDestinationPosY(sta.getBay1().shortValue()); // 目标库位列
|
crnCommand.setDestinationPosZ(sta.getLev1().shortValue()); // 目标库位层
|
if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
|
log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
|
}
|
}
|
|
/**
|
* 执行对工作档的入库完成
|
*/
|
public void storeFinished() {
|
for (CrnSlave crn : slaveProperties.getCrn()) {
|
// 获取堆垛机信息
|
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
|
CrnProtocol crnProtocol = crnThread.getCrnProtocol();
|
// 状态：等待确认 并且 任务完成位 = 1
|
if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.taskFinish == 1 && crnProtocol.getTaskNo() != 0) {
|
// 获取入库待确认工作档
|
WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
|
if (wrkMast == null) {
|
log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
|
continue;
|
}
|
// 如果工作状态为3.吊车入库中，则修改为4.入库完成
|
if (wrkMast.getWrkSts() == 3) {
|
Date now = new Date();
|
wrkMast.setWrkSts(4L);
|
wrkMast.setCrnEndTime(now);
|
wrkMast.setModiTime(now);
|
// 修改成功后复位堆垛机
|
if (wrkMastMapper.updateById(wrkMast) > 0) {
|
|
}
|
}
|
|
|
}
|
|
|
|
}
|
}
|
|
/**
|
* 更新堆垛机移动时工作档状态
|
*/
|
public void updateCrnMove() {
|
for (CrnSlave crn : slaveProperties.getCrn()) {
|
// 获取堆垛机信息
|
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
|
CrnProtocol crnProtocol = crnThread.getCrnProtocol();
|
// todo
|
if (crnProtocol.getStatusType() == CrnStatusType.FETCH_POSITION) {
|
|
WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
|
|
|
}
|
|
|
}
|
}
|
}
|
