package com.mes.job;
|
|
import cn.hutool.core.lang.Assert;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.mes.bigstorage.entity.BigStorageCageDetails;
|
import com.mes.bigstorage.entity.BigStorageDTO;
|
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
|
import com.mes.bigstorage.service.BigStorageCageDetailsService;
|
import com.mes.bigstorage.service.BigStorageCageService;
|
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
|
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
|
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
|
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
|
import com.mes.common.S7object;
|
import com.mes.common.config.Const;
|
import com.mes.device.PlcParameterObject;
|
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
|
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
|
import com.mes.glassinfo.entity.GlassInfo;
|
import com.mes.glassinfo.service.GlassInfoService;
|
import com.mes.temperingglass.entity.TemperingGlassInfo;
|
import com.mes.temperingglass.service.TemperingGlassInfoService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Component;
|
|
import javax.annotation.Resource;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author SNG-015
|
*/
|
@Component
|
@Slf4j
|
public class PlcStorageCageTask {
|
|
@Resource
|
private BigStorageCageService bigStorageCageService;
|
@Resource
|
private BigStorageCageDetailsService bigStorageCageDetailsService;
|
@Resource
|
private GlassInfoService glassInfoService;
|
@Resource
|
private BigStorageCageFeedTaskService bigStorageCageFeedTaskService;
|
@Resource
|
private BigStorageCageOutTaskService bigStorageCageOutTaskService;
|
@Resource
|
private EdgGlassTaskInfoService edgGlassTaskInfoService;
|
@Resource
|
private TemperingGlassInfoService temperingGlassInfoService;
|
|
@Value("${mes.sequence.order}")
|
private boolean sequenceOrder;
|
|
public static boolean bigStorageCageFullAlarm = false;
|
|
private int line1Time = 0;
|
private int line2Time = 0;
|
|
/**
|
* fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
|
* fixedDelay : 上一个调用结束后再次调用的延时
|
*/
|
// @Scheduled(fixedDelay = 5000)
|
// public void plcStorageCageTask() throws InterruptedException {
|
//
|
// PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
|
// try {
|
//
|
// String plcFeedGlassid = "";
|
// String plcFeedReqLine = "0";
|
// if ("1".equals(plcParameterObject.getPlcParameter("D01Request").getValue())) {
|
// plcFeedReqLine = "1";
|
// plcFeedGlassid = plcParameterObject.getPlcParameter("D01ID1").getValue();
|
// }
|
// if ("1".equals(plcParameterObject.getPlcParameter("D04Request").getValue())) {
|
// plcFeedReqLine = "2";
|
// plcFeedGlassid = plcParameterObject.getPlcParameter("D04ID1").getValue();
|
// }
|
// line1Time += 1;
|
// line2Time += 1;
|
//
|
// if (!("0".equals(plcFeedReqLine))) {
|
// log.info("1、Plc进片请求时");
|
// BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
|
// GlassInfo glassInfo = glassInfoService.getById(plcFeedGlassid);
|
// log.info("2、根据玻璃id获取玻璃信息" + glassInfo);
|
// if (bigStorageCageDetailsService.selectGetBoard(plcFeedReqLine) >= 0) {
|
// BigStorageCageDetails slotInfo = bigStorageCageService.feedGlass(glassInfo, bigStorageCageDetails);
|
// if (slotInfo != null) {
|
// int taskType = edgGlassTaskInfoService.judgeTasktype(plcFeedReqLine);
|
// log.info("3、查询任务表判断当前任务类型为上车等到还是上车启动" + taskType);
|
// bigStorageCageFeedTaskService.addFeedTask(slotInfo, Integer.parseInt(plcFeedReqLine), taskType);
|
// log.info("4、添加任务到任务表");
|
// bigStorageCageFullAlarm = false;
|
// } else {
|
// bigStorageCageFullAlarm = true;
|
// }
|
// } else {
|
// log.info("当前玻璃宽度不够上车" + glassInfo);
|
// if (!("1".equals(plcFeedReqLine))) {
|
// S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
|
// } else {
|
// S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
|
// }
|
// }
|
// } else {
|
// List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskService.querybigStorageCageFeedTask(1);
|
// log.info("5、查询任务表是否有已经完成的进片任务" + bigStorageCageFeedTaskList.size());
|
// for (BigStorageCageFeedTask bigStorageCageFeedTask : bigStorageCageFeedTaskList
|
// ) {
|
// BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
|
// bigStorageCageDetails.setId(bigStorageCageFeedTask.getId());
|
// bigStorageCageDetails.setState(1);
|
// bigStorageCageDetailsService.updateById(bigStorageCageDetails);
|
// log.info("6、修改理片笼详情玻璃状态");
|
// bigStorageCageFeedTaskService.removeById(bigStorageCageFeedTask);
|
// log.info("7、删除已经完成的进片任务");
|
// }
|
// //启动阈值
|
// if (line1Time >= 300) {
|
// if ("0".equals(plcParameterObject.getPlcParameter("D05Go").getValue())) {
|
// S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
|
// }
|
// }
|
// if (line2Time >= 300) {
|
// if ("0".equals(plcParameterObject.getPlcParameter("D02Go").getValue())) {
|
// S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
|
// }
|
// }
|
// }
|
//
|
// //查询出片表是否有任务未完成的任务
|
// List<BigStorageCageOutTask> bigStorageCageOutTask = bigStorageCageOutTaskService.querybigStorageCageOutTask(0);
|
// if (bigStorageCageOutTask.size() == 0) {
|
// boolean result = bigStorageCageService.outGlass();
|
// log.info("8、没有未完成任务时调用出片接口");
|
// if (result == false) {
|
// temperingGlassInfoService.schedulingTask();
|
// }
|
// }
|
// bigStorageCageOutTaskService.updateOutTask();
|
// log.info("9、根据任务表状态修改钢化小片表任务状态");
|
//
|
// //来不及送时直接走
|
// String line = Integer.toString(edgGlassTaskInfoService.startTask());
|
//
|
// if (!(line.equals(plcFeedReqLine))) {
|
// S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
|
// } else {
|
// S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
|
// }
|
//
|
//
|
// } catch (Exception e) {
|
// e.printStackTrace();
|
// }
|
// }
|
@Scheduled(fixedDelay = 5000)
|
public void plcToHomeEdgScan() {
|
PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
|
String d01Request = plcParameterObject.getPlcParameter("D01Request").getValue();
|
String d01ID1 = plcParameterObject.getPlcParameter("D01ID1").getValue();
|
String d04Request = plcParameterObject.getPlcParameter("D04Request").getValue();
|
String d04ID1 = plcParameterObject.getPlcParameter("D04ID1").getValue();
|
log.info("1、获取到的请求字d01为：{}，获取到的扫描ID为：{};获取到的请求字d04为：{}，获取到的扫描ID为：{};",
|
d01Request, d01ID1, d04Request, d04ID1);
|
if (!"1".equals(d01Request) && !"1".equals(d04Request)) {
|
log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
|
return;
|
}
|
// 0：不干预 ； 1：条件满足情况下立即发车
|
String d02GoAdress = plcParameterObject.getPlcParameter("D02Go").getAddress();
|
// 0：不干预 ； 1：条件满足情况下立即发车
|
String d05GoAdress = plcParameterObject.getPlcParameter("D05Go").getAddress();
|
Boolean flag01 = Boolean.FALSE;
|
Boolean flag04 = Boolean.FALSE;
|
//按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃
|
if ("1".equals(d01Request)) {
|
flag01 = judgeGlassTypeStatus(d01ID1, Const.A09_OUT_TARGET_POSITION);
|
}
|
if ("1".equals(d04Request)) {
|
flag04 = judgeGlassTypeStatus(d04ID1, Const.A10_OUT_TARGET_POSITION);
|
}
|
if (flag01 && flag04) {
|
//比较最早一片任务的版图id及版序 求出卧转立的线路
|
Integer startLine = getStartLine();
|
//计算目标格子，发送启动任务
|
computeTargetByLine(startLine, d02GoAdress, d05GoAdress);
|
} else if (flag01 || flag04) {
|
Integer startLine = flag01.equals(Boolean.TRUE) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
|
//计算目标格子，发送启动任务
|
computeTargetByLine(startLine, d02GoAdress, d05GoAdress);
|
} else {
|
log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
|
}
|
}
|
|
@Scheduled(fixedDelay = 5000)
|
public void plcToHomeEdgFreeCarTask() {
|
PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
|
String freeCar = plcParameterObject.getPlcParameter("freeCar").getValue();
|
if ("1".equals(freeCar)) {
|
log.info("大车非空闲");
|
return;
|
}
|
String d01Request = plcParameterObject.getPlcParameter("D01Request").getValue();
|
String d01ID1 = plcParameterObject.getPlcParameter("D01ID1").getValue();
|
String d04Request = plcParameterObject.getPlcParameter("D04Request").getValue();
|
String d04ID1 = plcParameterObject.getPlcParameter("D04ID1").getValue();
|
log.info("1、获取到的请求字d01为：{}，获取到的扫描ID为：{};获取到的请求字d04为：{}，获取到的扫描ID为：{};",
|
d01Request, d01ID1, d04Request, d04ID1);
|
//两条线都有进卧转立任务，直接结束
|
if (Const.BIG_STORAGE_REQUEST_IN.equals(d01Request)
|
&& Const.BIG_STORAGE_REQUEST_IN.equals(d04Request)
|
&& StringUtils.isNotBlank(d01ID1)
|
&& StringUtils.isNotBlank(d04ID1)) {
|
log.info("两条线都存在进片任务，结束任务");
|
return;
|
}
|
//获取两条线卧转立是否有玻璃，且任务状态都为2
|
List<String> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
|
if (CollectionUtils.isEmpty(lineList)) {
|
log.info("两条线卧转立为空或者有进片任务未完成，结束任务");
|
return;
|
}
|
// 0：不干预 ； 1：条件满足情况下立即发车
|
String d02GoAdress = plcParameterObject.getPlcParameter("D02Go").getAddress();
|
// 0：不干预 ； 1：条件满足情况下立即发车
|
String d05GoAdress = plcParameterObject.getPlcParameter("D05Go").getAddress();
|
String line1 = lineList.get(0);
|
String flagLine = line1.equals(Const.A09_OUT_TARGET_POSITION) ? d01ID1 : d04ID1;
|
if (lineList.size() == 1) {
|
//发送
|
if (StringUtils.isNotBlank(flagLine)) {
|
return;
|
}
|
//计算任务表进片格子 发送进片任务
|
computeTargetByLine(Integer.parseInt(flagLine), d02GoAdress, d05GoAdress);
|
}
|
if (StringUtils.isBlank(d01ID1) && StringUtils.isBlank(d04ID1)) {
|
//比较最早一片任务的版图id及版序 求出卧转立的线路
|
Integer line = getStartLine();
|
//计算任务表进片格子 发送进片任务
|
computeTargetByLine(line, d02GoAdress, d05GoAdress);
|
return;
|
}
|
int outLine = StringUtils.isBlank(d01ID1) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
|
//计算任务表进片格子 发送进片任务
|
computeTargetByLine(outLine, d02GoAdress, d05GoAdress);
|
}
|
|
@Scheduled(fixedDelay = 5000)
|
public void plcToHomeEdgOutTask() {
|
//todo:是否有正在出片的钢化任务
|
List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
|
.eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
|
.orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
|
//任务数据 获取车子存放玻璃最大数量 玻璃间隔
|
List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
|
if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
|
log.info("有正在出片的钢化任务");
|
//打车剩余尺寸
|
AtomicReference<Integer> remainWidth = new AtomicReference<>(Const.BIG_STORAGE_WIDTH);
|
temperingGlassInfoList.stream().forEach(e -> {
|
if (bigStorageCageOutTaskList.size() > 5 || e.getWidth() > remainWidth.get()) {
|
return;
|
}
|
remainWidth.set(remainWidth.get() - e.getWidth().intValue() - Const.BIG_STORAGE_GAP);
|
bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getState(), Const.A09_OUT_TARGET_POSITION,
|
0, 0, 1));
|
});
|
bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
|
return;
|
}
|
|
//todo:获取状态字 钢化优先 or 人工下片优先
|
if (true) {
|
//todo:钢化优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐
|
TemperingLayoutDTO temperingLayoutDTO = bigStorageCageDetailsService.temperingIsAll();
|
if (null != temperingLayoutDTO) {
|
//玻璃到齐
|
//todo: 到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务 结束
|
List<BigStorageCageDetails> bigStorageCageDetails = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
|
.eq(BigStorageCageDetails::getTemperingLayoutId, temperingLayoutDTO.getTemperingLayoutId())
|
.eq(BigStorageCageDetails::getEngineerId, temperingLayoutDTO.getEngineerId()));
|
List<TemperingGlassInfo> temperingGlassInfos = bigStorageCageDetails.stream().map(e -> {
|
TemperingGlassInfo info = new TemperingGlassInfo();
|
BeanUtils.copyProperties(e, info);
|
return info;
|
}).collect(Collectors.toList());
|
temperingGlassInfoService.saveBatch(temperingGlassInfos);
|
|
//打车剩余尺寸
|
AtomicReference<Integer> remainWidth = new AtomicReference<>(Const.BIG_STORAGE_WIDTH);
|
temperingGlassInfoList.stream().forEach(e -> {
|
if (bigStorageCageOutTaskList.size() > 5 || e.getWidth() > remainWidth.get()) {
|
return;
|
}
|
remainWidth.set(remainWidth.get() - e.getWidth().intValue() - Const.BIG_STORAGE_GAP);
|
bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getState(), Const.A09_OUT_TARGET_POSITION,
|
0, 0, 1));
|
});
|
bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
|
return;
|
}
|
//todo: 未到齐 执行内部调度任务 结束
|
|
}
|
//todo:笼内是否有人工下片玻璃 有直接出 无 结束
|
|
|
}
|
|
|
/**
|
* 按照玻璃id判断玻璃状态及卧转立是否可直接启动
|
*/
|
public Boolean judgeGlassTypeStatus(String glassId, Integer line) {
|
//1、获取任务表中相邻玻璃
|
List<EdgGlassTaskInfo> edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
|
.eq(EdgGlassTaskInfo::getLine, line)
|
.apply("time >= (select time from edg_glass_task_info where glass_id = '" + glassId + "')")
|
.orderByAsc(EdgGlassTaskInfo::getTime));
|
Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");
|
//2、获取卧转立剩余宽度
|
Map<String, Object> map = bigStorageCageFeedTaskService.getMap(new QueryWrapper<BigStorageCageFeedTask>()
|
.select("cast(5000 - sum(width + 20) as INT)as remainWidth")
|
.eq("line", line).eq("task_state", Const.BIG_STORAGE_IN_UP));
|
Integer remainWidth = null == map ? 5000 : Integer.parseInt(map.get("remainWidth") + "");
|
//2、获取卧转立
|
Integer widthFirst = edgGlassTaskInfoList.get(0).getWidth();
|
if (edgGlassTaskInfoList.size() == 1) {
|
if (remainWidth >= widthFirst) {
|
addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
|
return Boolean.FALSE;
|
} else {
|
//记录无法放下玻璃，后续判断启动
|
return Boolean.TRUE;
|
}
|
}
|
Integer widthSecond = edgGlassTaskInfoList.get(1).getWidth();
|
if (remainWidth >= widthFirst) {
|
if (remainWidth - widthFirst - Const.BIG_STORAGE_GAP >= widthSecond) {
|
addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthSecond);
|
} else {
|
addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthSecond);
|
}
|
return Boolean.FALSE;
|
|
} else {
|
return Boolean.TRUE;
|
}
|
}
|
|
/**
|
* 添加任务信息
|
*/
|
private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width) {
|
BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask();
|
bigStorageCageFeedTask.setGlassId(glassId);
|
bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_REQUEST_IN);
|
bigStorageCageFeedTask.setLine(line);
|
bigStorageCageFeedTask.setTaskType(taskType);
|
bigStorageCageFeedTask.setWidth(width);
|
bigStorageCageFeedTask.setCreateTime(new Date());
|
return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask);
|
}
|
|
/**
|
* 获取需要启动的线路：两条线都可启动 获取第一片玻璃版图id最小 版序最大的线路
|
*
|
* @return
|
*/
|
public Integer getStartLine() {
|
List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
|
.inSql(BigStorageCageFeedTask::getId, "select min(id) from big_storage_cage_feed_task where task_state = 2 group by line"));
|
Assert.isFalse(CollectionUtils.isEmpty(taskList), "卧转立两条线都没有玻璃进片任务");
|
Map<String, Integer> taskMap = taskList.stream().collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId,
|
BigStorageCageFeedTask::getLine));
|
GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
|
.in(GlassInfo::getGlassId, taskMap.keySet())
|
.orderByAsc(GlassInfo::getTemperingLayoutId)
|
.orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
|
.last("limit 1"));
|
return taskMap.get(glassInfo.getGlassId());
|
}
|
|
/**
|
* 计算任务表进片线路的目标格子，并启动任务
|
*/
|
public boolean computeTargetByLine(Integer line, String d02GoAdress, String d05GoAdress) {
|
//1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
|
List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
|
.eq(BigStorageCageFeedTask::getLine, line)
|
.eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
|
.orderByAsc(BigStorageCageFeedTask::getId));
|
//2、去笼子内查找是否可以继续存放的笼子
|
List<String> glassIds = taskList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
|
List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds));
|
AtomicReference<Integer> temperingLayoutIdTemp = new AtomicReference<>(0);
|
AtomicReference<Integer> temperingFeedSequenceTemp = new AtomicReference<>(0);
|
AtomicReference<BigStorageDTO> bigStorageDTO = new AtomicReference<>(new BigStorageDTO());
|
Map<String, GlassInfo> glassInfoMap = glassInfos.stream().collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
|
List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
|
AtomicBoolean taskFlag = new AtomicBoolean(Boolean.TRUE);
|
taskList.stream().forEach(e -> {
|
BigStorageCageDetails cageDetails = new BigStorageCageDetails();
|
//按照版图信息获取进片笼子格子号
|
GlassInfo info = glassInfoMap.get(e.getGlassId());
|
BeanUtils.copyProperties(info, cageDetails);
|
if (temperingLayoutIdTemp.equals(info.getTemperingLayoutId())
|
&& temperingFeedSequenceTemp.equals(info.getTemperingFeedSequence() + 1)
|
&& info.getWidth() <= bigStorageDTO.get().getWidth()) {
|
bigStorageDTO.get().setWidth(bigStorageDTO.get().getWidth() - info.getWidth().intValue() - Const.BIG_STORAGE_GAP);
|
} else {
|
bigStorageDTO.set(bigStorageCageDetailsService.queryTargetSlotByTempering(info));
|
}
|
e.setTargetSlot(bigStorageDTO.get().getSlot());
|
cageDetails.setSlot(bigStorageDTO.get().getSlot());
|
cageDetails.setState(Const.GLASS_STATE_IN);
|
temperingLayoutIdTemp.set(info.getTemperingLayoutId());
|
temperingFeedSequenceTemp.set(info.getTemperingFeedSequence());
|
bigStorageCageDetailsList.add(cageDetails);
|
taskFlag.set(bigStorageCageFeedTaskService.updateById(e));
|
if (!taskFlag.get()) {
|
return;
|
}
|
});
|
//3、更新进片任务表 遇到问题：无法批量更新，批量更新无法走指定从库
|
|
//4、在详情表中加入进片玻璃信息
|
bigStorageCageDetailsService.saveBatch(bigStorageCageDetailsList);
|
if (taskFlag.get()) {
|
String lineAddress = line.equals(Const.A09_OUT_TARGET_POSITION) ? d02GoAdress : d05GoAdress;
|
// S7object.getinstance().plccontrol.writeWord(lineAddress, (short) 1);
|
}
|
return taskFlag.get();
|
}
|
}
|
