From 9d961999ca32c97c31174179dd7bc763c245d7f6 Mon Sep 17 00:00:00 2001
From: zhoushihao <zsh19950802@163.com>
Date: 星期三, 15 十月 2025 16:47:03 +0800
Subject: [PATCH] 1、 最终方案:新增db地址,mes将玻璃信息写入地址
---
hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java | 906 +++++++++++++++++++++++++++++++++++++++-----------------
1 files changed, 625 insertions(+), 281 deletions(-)
diff --git a/hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java b/hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java
index 733c1e3..78670a0 100644
--- a/hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java
+++ b/hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java
@@ -6,8 +6,12 @@
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
+import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
+import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
+import com.mes.alarm.entity.ProductAlarmInfo;
+import com.mes.alarm.service.ProductAlarmInfoService;
import com.mes.base.entity.HollowBigStorageCageBaseInfo;
import com.mes.bigstoragecagetask.entity.BigStorageCageTask;
import com.mes.bigstoragecagetask.service.BigStorageCageTaskService;
@@ -33,6 +37,9 @@
import com.mes.hollowqueue.service.HollowGlassQueueInfoService;
import com.mes.hollowtask.entity.HollowBigStorageCageHistoryTask;
import com.mes.hollowtask.service.HollowBigStorageCageHistoryTaskService;
+import com.mes.s7.entity.S7DataZKDLPOne;
+import com.mes.s7.entity.S7DataZKDLPTwo;
+import com.mes.s7.entity.S7DataZKExtra;
import com.mes.sysconfig.service.SysConfigService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
@@ -41,6 +48,7 @@
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@@ -79,8 +87,37 @@
@Resource
private SysConfigService sysConfigService;
+ @Autowired
+ @Qualifier("s7SerializerZKDLPOne")
+ private S7Serializer s7SerializerZKDLPOne;
+
+ @Autowired
+ @Qualifier("s7SerializerZKDLPTwo")
+ private S7Serializer s7SerializerZKDLPTwo;
+
+ @Autowired
+ @Qualifier("s7SerializerZKQ2")
+ private S7Serializer s7SerializerZKQ2;
+
+ @Autowired
+ @Qualifier("CMJ1ModbusTcp")
+ ModbusTcp CMJ1ModbusTcp;
+
+ @Resource
+ private ProductAlarmInfoService productAlarmInfoService;
+
private static final String BIG_STORAGE_CAGE_IN_TWO_TASK = "big_storage_cage_in_two_task";
private static final String BIG_STORAGE_CAGE_OUT_TWO_TASK = "big_storage_cage_out_two_task";
+
+ private static final List<Integer> ONE_LINE_FIRST = Arrays.asList(930, 931, 932);
+ private static final List<Integer> TWO_LINE_FIRST = Arrays.asList(931, 930, 932);
+
+
+ private static final String ALARM_MODULE = "涓┖";
+ private static final String ALARM_TYPE = "涓┖澶х悊鐗�";
+ private static final String ALARM_CODE_SIZE = "sizeSame";
+ private static final String ALARM_CODE_ID = "idSame";
+
/**
* 鐩撮�氭牸瀛�
*/
@@ -90,52 +127,46 @@
@Resource
private RedisUtil redisUtil;
-// @Value("${mes.slotWidth}")
-// private Integer slotWidth;
-//
-// @Value("${mes.glassGap}")
-// private Integer glassGap;
-//
-// @Value("${mes.carWidth}")
-// private Integer carWidth;
-//
-// @Value("${mes.outCarMaxSize}")
-// private Integer outCarMaxSize;
-//
-// @Value("${mes.slotMaxHeight}")
-// private Integer slotMaxHeight;
-// @Value("${mes.slotMaxthickness}")
-// private Integer slotMaxthickness;
-
@Scheduled(fixedDelay = 1000)
- public void inBigStorageTask() throws Exception {
- ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
- if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
+ public void inBigStorageTask() {
+ List<ProductAlarmInfo> alarmInfos = productAlarmInfoService.list(new LambdaQueryWrapper<ProductAlarmInfo>()
+ .eq(ProductAlarmInfo::getState, Const.LOAD_RAW_GLASS_NEW)
+ .eq(ProductAlarmInfo::getAlarmModule, ALARM_MODULE)
+ .eq(ProductAlarmInfo::getAlarmType, ALARM_TYPE));
+ if (CollectionUtil.isNotEmpty(alarmInfos)) {
+ log.info("鐣岄潰鎶ヨ锛岀瓑寰呬汉宸ュ共棰勫鐞�");
+ return;
+ }
+ S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
+ log.info("杩涚墖浠诲姟璇诲彇s7DataZKDLPOne:{}", s7DataZKDLPOne);
+ Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
+ if (!inkageEntity) {
log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫杩涚墖浠诲姟");
return;
}
- ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2A.DLP2A.RequestMes");
- if (!"1".equals(requestEntity.getValue() + "")) {
+ Integer requestEntity = s7DataZKDLPOne.getRequestMes();
+ if (1 != requestEntity) {
log.info("褰撳墠鏈敹鍒拌繘鐗囪姹傦紝缁撴潫杩涚墖浠诲姟");
return;
}
- ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP2A.DLP2A.MesReply");
- if ("1".equals(mesReplyEntity.getValue() + "")) {
+ Integer mesReplyEntity = s7DataZKDLPOne.getMesReply();
+ if (1 == mesReplyEntity) {
log.info("鏈夋鍦ㄦ墽琛岀殑浠诲姟锛岀粨鏉熻繘鐗囦换鍔�");
return;
}
List<BigStorageCageTask> inTaskList = new ArrayList();
- ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM1");
+ Integer from = s7DataZKDLPOne.getFrom1();
List<String> glassIdList = new ArrayList<>();
+ List<String> requestWords = s7DataZKDLPOne.getIds();
for (int i = 1; i <= 6; i++) {
- ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i);
- if (null != requestWord.getValue()) {
+ String requestWord = requestWords.get(i - 1);
+ if (null != requestWord && !requestWord.isEmpty()) {
BigStorageCageTask task = new BigStorageCageTask();
- task.setGlassId(requestWord.getValue() + "");
- task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
+ task.setGlassId(requestWord);
+ task.setStartSlot(from);
inTaskList.add(task);
- glassIdList.add(requestWord.getValue() + "");
+ glassIdList.add(requestWord);
continue;
}
}
@@ -143,13 +174,28 @@
log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫杩涚墖浠诲姟");
return;
}
+ //鐜荤拑鐘舵�佸瓨鍦ㄥ崸杞珛涓婄粨鏉�
+ List<BigStorageCageTask> unTaskList = inTaskList.stream().filter(e -> e.getTaskState() < 1).collect(Collectors.toList());
+ if (CollectionUtil.isNotEmpty(unTaskList)) {
+ log.info("瀛樺湪鏈笂杞︾殑鐜荤拑淇℃伅,鐜荤拑锛歿}", unTaskList);
+ return;
+ }
log.info("鑾峰彇浠诲姟鐨勭幓鐠僫d锛歿}", glassIdList);
Map<String, Long> glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
for (Map.Entry<String, Long> entry : glassCountMap.entrySet()) {
if (entry.getValue() > 1) {
log.info("杩涚墖鐜荤拑{}瀛樺湪鐩稿悓锛岀粨鏉熸湰娆′换鍔�", entry.getKey());
+ ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
+ alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
+ alarmInfo.setAlarmModule(ALARM_MODULE);
+ alarmInfo.setAlarmType(ALARM_TYPE);
+ alarmInfo.setAlarmCode(ALARM_CODE_ID);
+ alarmInfo.setAlarmMessage(entry.getKey());
+ productAlarmInfoService.save(alarmInfo);
//鍚憄lc鍙戦�佹姤璀�:鍚屼竴杞﹁繘鐗囩幓鐠冨瓨鍦ㄧ浉鍚�
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 2));
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setAlramSignal(2);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
return;
}
}
@@ -158,7 +204,19 @@
if (CollectionUtil.isNotEmpty(detailsList)) {
log.info("鐞嗙墖绗煎瓨鍦ㄧ浉鍚岀殑杩涚墖鐜荤拑{}锛岀粨鏉熸湰娆′换鍔�", detailsList);
//鍚憄lc鍙戦�佹姤璀�:鐞嗙墖绗煎瓨鍦ㄧ浉鍚岀殑杩涚墖鐜荤拑
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 4));
+ List<String> sameGlassIds = detailsList.stream()
+ .map(HollowBigStorageCageDetails::getGlassId)
+ .collect(Collectors.toList());
+ ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
+ alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
+ alarmInfo.setAlarmModule(ALARM_MODULE);
+ alarmInfo.setAlarmType(ALARM_TYPE);
+ alarmInfo.setAlarmCode(ALARM_CODE_ID);
+ alarmInfo.setAlarmMessage(sameGlassIds.toString());
+ productAlarmInfoService.save(alarmInfo);
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setAlramSignal(4);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
return;
}
List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList));
@@ -166,13 +224,17 @@
if (glassInfoList.size() != inTaskList.size()) {
log.info("杩涚墖浠诲姟鏁伴噺{}涓庣幓鐠冩暟閲弡}涓嶅尮閰嶏紝缁撴潫鏈杩涚墖", inTaskList.size(), glassInfoList.size());
//鍚憄lc鍙戦�佹姤璀�:杩涚墖浠诲姟鏁伴噺涓庣郴缁熸煡璇㈠埌鐨勭幓鐠冩暟閲忎笉鍖归厤
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 8));
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setAlramSignal(8);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
return;
}
Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
+ Integer slotMaxThickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
//鎸夌収鐜荤拑鍘氬害鍒嗙粍锛屽垽鏂墿浣欐牸瀛愭槸鍚﹀彲浠ュ瓨鏀�
Map<Double, Long> thickCountMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getThickness, Collectors.counting()));
+// if (glassInfoList.get(0).getThickness() < slotMaxThickness) {
for (Map.Entry<Double, Long> entry : thickCountMap.entrySet()) {
int count = hollowBigStorageCageService.count(new LambdaQueryWrapper<HollowBigStorageCage>()
.eq(HollowBigStorageCage::getEnableState, Const.SLOT_ON).eq(HollowBigStorageCage::getRemainWidth, slotWidth)
@@ -181,24 +243,29 @@
if (count < entry.getValue()) {
log.info("绗煎唴鏍煎瓙鍓╀綑鏁伴噺涓嶈冻锛岀粨鏉熸湰娆¤繘鐗�");
//鍚憄lc鍙戦�佹姤璀�:绗煎唴鏍煎瓙鍓╀綑鏁伴噺涓嶈冻
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 16));
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setAlramSignal(16);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
return;
}
}
+// }
//瓒呭ぇ灏哄
- Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_HEIGHT);
- Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
- if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) {
- int count = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
- .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT)
- .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
- if (count > 0) {
- log.info("鐩撮�氱墖鍙板瓨鍦ㄧ幓鐠冿紝缁撴潫鏈杩涚墖");
- //鍚憄lc鍙戦�佹姤璀�:鐩撮�氱墖鍙板瓨鍦ㄧ幓鐠冿紝鏃犳硶缁х画鐩撮��
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 64));
- return;
- }
- }
+// Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_HEIGHT);
+// Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
+// if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) {
+// int count = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
+// .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT)
+// .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
+// if (count > 0) {
+// log.info("鐩撮�氱墖鍙板瓨鍦ㄧ幓鐠冿紝缁撴潫鏈杩涚墖");
+// //鍚憄lc鍙戦�佹姤璀�:鐩撮�氱墖鍙板瓨鍦ㄧ幓鐠冿紝鏃犳硶缁х画鐩撮��
+// s7DataZKDLPOne = new S7DataZKDLPOne();
+// s7DataZKDLPOne.setAlramSignal(64);
+// s7SerializerZKDLPOne.write(s7DataZKDLPOne);
+// return;
+// }
+// }
log.info("灏嗛挗鍖栧皬鐗囪〃鍐呯殑鐘舵�佹敼涓洪挗鍖栫粨鏉燂紝鐜荤拑id鏈夛細{}", glassIdList);
//淇敼閽㈠寲浠诲姟琛ㄤ腑鐨勭姸鎬�
@@ -215,52 +282,81 @@
List<HollowBigStorageCageHistoryTask> historyTasks = new ArrayList<>();
Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
- try {
- if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
- for (BigStorageCageTask task : inTaskList) {
- GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
- HollowBigStorageDTO bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(),
+
+ log.info("寮�濮嬭绠楃洰鏍囨牸瀛�,鐜荤拑id鏈夛細{}", inTaskList);
+// if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
+ for (BigStorageCageTask task : inTaskList) {
+ if (from == 910) {
+ GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
+ HollowBigStorageDTO bigStorageDTO = null;
+ try {
+ bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getGlassType(),
info.getWidth(), info.getHeight(), info.getTotalLayer(), info.getLayer());
-// 涓存椂鏇存柊鏍煎瓙鐨勫墿浣欏昂瀵革細闃叉鐩搁偦鐜荤拑杩涘悓涓�鏍煎瓙閫犳垚鍓╀綑灏哄涓嶈冻锛岀幓鐠冭秺鐣岀殑鎯呭喌锛屼换鍔″畬鎴愬悗鍐嶆鏇存柊澶х悊鐗囩琛ㄥ墿浣欏搴︼紙鎸夌収绗煎唴鐜荤拑鏁伴噺鏇存柊澶х悊鐗囩鍓╀綑灏哄锛�
- hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
- .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
- .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
- task.setTargetSlot(bigStorageDTO.getSlot());
- task.setGlassId(info.getGlassId());
- bigStorageCageTaskService.updateTaskMessage(BIG_STORAGE_CAGE_IN_TWO_TASK, task);
- //瀛樻斁鍘嗗彶浠诲姟
- HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
- BeanUtils.copyProperties(task, historyTask);
- historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN);
- historyTask.setGlassCount(glassInfoList.size());
- historyTask.setTaskState(Const.ENGINEERING_NEW);
- historyTasks.add(historyTask);
- //瀛樻斁璇︽儏鏁版嵁
- HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
- BeanUtils.copyProperties(bigStorageDTO, cageDetails);
- BeanUtils.copyProperties(info, cageDetails);
- cageDetails.setState(Const.GLASS_STATE_NEW);
- cageDetails.setSequence(bigStorageDTO.getSlotSequence());
- cageDetails.setGap(glassGap);
- cageDetails.setId(null);
- hollowBigStorageCageDetailsService.save(cageDetails);
+ } catch (Exception exception) {
+ log.info("杩涚墖浠诲姟鎵ц涓彂鐢熷紓甯革細{}", exception);
+ //淇濆瓨鏁呴殰淇℃伅
+ ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
+ alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
+ alarmInfo.setAlarmModule(ALARM_MODULE);
+ alarmInfo.setAlarmType(ALARM_TYPE);
+ alarmInfo.setAlarmCode(ALARM_CODE_SIZE);
+ alarmInfo.setAlarmMessage(info.getGlassId());
+ productAlarmInfoService.save(alarmInfo);
+ //閲嶇疆璇︽儏琛ㄦ暟鎹�
+ hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
+ .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_TAKE)
+ .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW));
+ //閲嶇疆涓┖鍏崇郴琛ㄦ暟鎹�
hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
- .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId())
- .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId())
- .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence())
- .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId())
- .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
- .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId())
- .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer())
- .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot())
- .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
- .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
+ .set(HollowGlassRelationInfo::getGlassId, null)
+ .set(HollowGlassRelationInfo::getTemperingLayoutId, null)
+ .set(HollowGlassRelationInfo::getTemperingFeedSequence, null)
+ .set(HollowGlassRelationInfo::getEngineerId, null)
+ .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_NEW)
+ .eq(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
);
+ //灏嗘牸瀛愬昂瀵告仮澶�
+ hollowBigStorageCageService.resetCage();
+ return;
}
+
+// 涓存椂鏇存柊鏍煎瓙鐨勫墿浣欏昂瀵革細闃叉鐩搁偦鐜荤拑杩涘悓涓�鏍煎瓙閫犳垚鍓╀綑灏哄涓嶈冻锛岀幓鐠冭秺鐣岀殑鎯呭喌锛屼换鍔″畬鎴愬悗鍐嶆鏇存柊澶х悊鐗囩琛ㄥ墿浣欏搴︼紙鎸夌収绗煎唴鐜荤拑鏁伴噺鏇存柊澶х悊鐗囩鍓╀綑灏哄锛�
+ hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
+ .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
+ .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
+ task.setTargetSlot(bigStorageDTO.getSlot());
+ task.setGlassId(info.getGlassId());
+ //瀛樻斁鍘嗗彶浠诲姟
+ HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
+ BeanUtils.copyProperties(task, historyTask);
+ historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN);
+ historyTask.setGlassCount(glassInfoList.size());
+ historyTask.setTaskState(Const.ENGINEERING_NEW);
+ historyTasks.add(historyTask);
+ //瀛樻斁璇︽儏鏁版嵁
+ HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
+ BeanUtils.copyProperties(bigStorageDTO, cageDetails);
+ BeanUtils.copyProperties(info, cageDetails);
+ cageDetails.setState(Const.GLASS_STATE_NEW);
+ cageDetails.setSequence(bigStorageDTO.getSlotSequence());
+ cageDetails.setGap(glassGap);
+ cageDetails.setId(null);
+ hollowBigStorageCageDetailsService.save(cageDetails);
+ hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
+ .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId())
+ .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId())
+ .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence())
+ .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId())
+ .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
+ .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId())
+ .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer())
+ .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot())
+ .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
+ .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
+ );
+
} else {
- BigStorageCageTask task = inTaskList.get(0);
task.setTargetSlot(THROUGH_SLOT);
- bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_two_task", task);
//瀛樻斁鍘嗗彶浠诲姟
HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
BeanUtils.copyProperties(task, historyTask);
@@ -281,80 +377,120 @@
cageDetails.setId(null);
hollowBigStorageCageDetailsService.save(cageDetails);
}
- } catch (Exception exception) {
- log.info("杩涚墖浠诲姟鎵ц涓彂鐢熷紓甯革細{}", exception);
- hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
- .set(HollowGlassRelationInfo::getGlassId, null)
- .set(HollowGlassRelationInfo::getTemperingLayoutId, null)
- .set(HollowGlassRelationInfo::getTemperingFeedSequence, null)
- .set(HollowGlassRelationInfo::getEngineerId, null)
- .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_NEW)
- .eq(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
- );
}
+
//鍘嗗彶鏁版嵁鍏ュ簱
hollowBigStorageCageHistoryTaskService.saveBatch(historyTasks);
//鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
- List<ReadWriteEntity> list = new ArrayList<>();
- for (int i = 1; i <= inTaskList.size(); i++) {
- list.add(generateReadWriteEntity("DLP2A.DLP2A.TO" + i, inTaskList.get(i - 1).getTargetSlot()));
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ for (int i = 0; i < inTaskList.size() && i < 6; i++) {
+ Integer value = inTaskList.get(i).getTargetSlot();
+ switch (i) {
+ case 0:
+ s7DataZKDLPOne.setTo1(value);
+ break;
+ case 1:
+ s7DataZKDLPOne.setTo2(value);
+ break;
+ case 2:
+ s7DataZKDLPOne.setTo3(value);
+ break;
+ case 3:
+ s7DataZKDLPOne.setTo4(value);
+ break;
+ case 4:
+ s7DataZKDLPOne.setTo5(value);
+ break;
+ case 5:
+ s7DataZKDLPOne.setTo6(value);
+ break;
+ }
}
- list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 1));
- miloService.writeToOpcWord(list);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setMesReply(1);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
}
@Scheduled(fixedDelay = 1000)
public void outBigStorageTask() throws Exception {
Date startDate = new Date();
- ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
- if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
+ S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
+ log.info("鍑虹墖浠诲姟璇诲彇s7DataZKDLPTwo:{}", s7DataZKDLPTwo);
+ Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
+ if (!inkageEntity) {
log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫杩涚墖浠诲姟");
return;
}
- ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2B.DLP2B.RequestMes");
- if (!"1".equals(requestEntity.getValue() + "")) {
+ Integer requestEntity = s7DataZKDLPTwo.getRequestMes();
+ if (1 != requestEntity) {
log.info("褰撳墠鏈敹鍒板嚭鐗囪姹傦紝缁撴潫鍑虹墖浠诲姟");
return;
}
//鑾峰彇鍑虹墖浠诲姟琛�
- List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
+ List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
if (CollectionUtil.isNotEmpty(outTaskList)) {
log.info("鏈夋鍦ㄦ墽琛岀殑鍑虹墖浠诲姟锛岀粨鏉熸湰娆″嚭鐗囦换鍔�");
return;
}
-
+ //鑾峰彇鎵�鏈夌┖闂茬殑绾胯矾淇℃伅
+ HashMap<Integer, Boolean> map = new HashMap<>();
//鑾峰彇绌洪棽涓旈鍙栦换鍔＄殑鏁版嵁淇℃伅锛屾病鏈変换鍔＄洿鎺ヨ蛋鐜荤拑璋冨害
- HashMap<Integer, ReadWriteEntity> map = new HashMap<>();
- ReadWriteEntity oneEntity = miloService.readFromOpcUa("CMJ1.CMJ1.isFree");
- ReadWriteEntity twoEntity = miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree");
- ReadWriteEntity threeEntity = miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree03");
- map.put(930, oneEntity);
- map.put(931, twoEntity);
- map.put(932, threeEntity);
+ try {
+ if (CMJ1ModbusTcp.checkConnected()) {
+ Boolean oneState = CMJ1ModbusTcp.readUInt16(42027 - 40001) != 0;
+ map.put(930, oneState);
+ } else {
+ map.put(930, Boolean.FALSE);
+ }
+ } catch (Exception e) {
+ //nothing
+ log.info("涓�绾跨┖闂茬姸鎬佽幏鍙栧紓甯�");
+ }
+ try {
+ S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
+ log.info("涓┖棰濆璇诲彇{}", s7DataZKExtra);
+ map.put(931, s7DataZKExtra.getIsFree());
+ map.put(932, s7DataZKExtra.getIsFree03());
+ } catch (Exception e) {
+ //nothing
+ log.info("浜�/涓夌嚎绾跨┖闂茬姸鎬佽幏鍙栧紓甯�");
+ }
+ List<Integer> resultList = new ArrayList<>();
+ if (redisUtil.getCacheObject("priorityHollowSwitch")) {
+ resultList = TWO_LINE_FIRST;
+ } else {
+ resultList = ONE_LINE_FIRST;
+ }
+
HollowGlassOutRelationInfo hollowGlassOutRelationInfo = null;
int cell = -1;
- for (int i = 930; i <= 932; i++) {
+ for (Integer i : resultList) {
if (null == hollowGlassOutRelationInfo) {
- ReadWriteEntity entity = map.get(i);
+ Boolean entity = map.get(i);
cell = i;
- if (null != entity.getValue() && ("1".equals(entity.getValue() + "") || Boolean.parseBoolean(entity.getValue() + ""))) {
+ if (null != entity && entity) {
hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
.getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
.eq(HollowGlassOutRelationInfo::getCell, cell)
.eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
+ .orderByAsc(HollowGlassOutRelationInfo::getId)
+ .last("limit 1")
);
}
} else {
break;
}
}
- for (int i = 930; i <= 932; i++) {
+ for (Integer i : resultList) {
if (null == hollowGlassOutRelationInfo) {
cell = i;
hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
.getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
.eq(HollowGlassOutRelationInfo::getCell, cell)
.eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
+ .orderByAsc(HollowGlassOutRelationInfo::getId)
+ .last("limit 1")
);
} else {
break;
@@ -367,7 +503,7 @@
// 鑾峰彇褰撳墠涓┖浠诲姟鏈畬鎴愬嚭鐗囩殑鐜荤拑淇℃伅
List<HollowGlassQueueInfo> unFinishHollowQueueList = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
.eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassOutRelationInfo.getFlowCardId())
- .eq(HollowGlassQueueInfo::getCell, cell)
+ .eq(HollowGlassQueueInfo::getCell, hollowGlassOutRelationInfo.getCell())
.eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
.orderByAsc(HollowGlassQueueInfo::getHollowSequence));
if (CollectionUtil.isNotEmpty(unFinishHollowQueueList)) {
@@ -385,7 +521,6 @@
.set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_SUCCESS));
}
}
-// redisUtil.setCacheObject("dispatchHollowSwitch",true);
//鏄惁瀛樺湪闇�瑕佸唴閮ㄨ皟搴︾殑鏍煎瓙:鎵ц鍐呴儴璋冨害浠诲姟
if (redisUtil.getCacheObject("dispatchHollowSwitch")) {
//todo:鑾峰彇绗煎唴鍗曟牸宸茬粡鍒伴綈鐨勭幓鐠冩牸瀛愪俊鎭�
@@ -427,33 +562,73 @@
@Scheduled(fixedDelay = 1000)
public void finishInBigStorageTask() throws Exception {
- ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
- if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
+ S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
+ Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
+ if (true != inkageEntity) {
log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫瀹屾垚杩涚墖浠诲姟");
return;
}
//鑾峰彇杩涚墖浠诲姟琛�
List<BigStorageCageTask> inTaskList = new ArrayList();
List<String> glassIdList = new ArrayList<>();
- ReadWriteEntity toWord = miloService.readFromOpcUa("DLP2A.DLP2A.TO1");
- if ("0".equals(toWord.getValue() + "")) {
+ String toWord = s7DataZKDLPOne.getTo1().toString();
+ if ("0".equals(toWord)) {
log.info("瀹屾垚浠诲姟宸叉墽琛岋紝缁撴潫鏈瀹屾垚杩涚墖浠诲姟");
return;
}
for (int i = 1; i <= 6; i++) {
- ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i);
- ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP2A.DLP2A.STATE" + i);
- ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.TO" + i);
- ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM" + i);
+ String requestWord = "";
+ String statetWord = "";
+ String toOpcUa = "";
+ String fromOpcUa = "";
+ switch (i) {
+ case 1:
+ requestWord = s7DataZKDLPOne.getId1();
+ statetWord = s7DataZKDLPOne.getState1().toString();
+ toOpcUa = s7DataZKDLPOne.getTo1().toString();
+ fromOpcUa = s7DataZKDLPOne.getFrom1().toString();
+ break;
+ case 2:
+ requestWord = s7DataZKDLPOne.getId2();
+ statetWord = s7DataZKDLPOne.getState2().toString();
+ toOpcUa = s7DataZKDLPOne.getTo2().toString();
+ fromOpcUa = s7DataZKDLPOne.getFrom2().toString();
+ break;
+ case 3:
+ requestWord = s7DataZKDLPOne.getId3();
+ statetWord = s7DataZKDLPOne.getState3().toString();
+ toOpcUa = s7DataZKDLPOne.getTo3().toString();
+ fromOpcUa = s7DataZKDLPOne.getFrom3().toString();
+ break;
+ case 4:
+ requestWord = s7DataZKDLPOne.getId4();
+ statetWord = s7DataZKDLPOne.getState4().toString();
+ toOpcUa = s7DataZKDLPOne.getTo4().toString();
+ fromOpcUa = s7DataZKDLPOne.getFrom4().toString();
+ break;
+ case 5:
+ requestWord = s7DataZKDLPOne.getId5();
+ statetWord = s7DataZKDLPOne.getState5().toString();
+ toOpcUa = s7DataZKDLPOne.getTo5().toString();
+ fromOpcUa = s7DataZKDLPOne.getFrom5().toString();
+ break;
+ case 6:
+ requestWord = s7DataZKDLPOne.getId6();
+ statetWord = s7DataZKDLPOne.getState6().toString();
+ toOpcUa = s7DataZKDLPOne.getTo6().toString();
+ fromOpcUa = s7DataZKDLPOne.getFrom6().toString();
+ break;
+ }
- if (null != requestWord.getValue()) {
+// if (null != requestWord.getValue()) {
+ if (null != requestWord && !requestWord.isEmpty()) {
BigStorageCageTask task = new BigStorageCageTask();
- task.setGlassId(requestWord.getValue() + "");
- task.setTargetSlot(Integer.parseInt(toOpcUa.getValue() + ""));
- task.setTaskState(Integer.parseInt(statetWord.getValue() + ""));
- task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
+ task.setGlassId(requestWord);
+ task.setTargetSlot(Integer.parseInt(toOpcUa));
+ task.setTaskState(Integer.parseInt(statetWord));
+ task.setStartSlot(Integer.parseInt(fromOpcUa));
inTaskList.add(task);
- glassIdList.add(requestWord.getValue() + "");
+ glassIdList.add(requestWord);
continue;
}
}
@@ -525,151 +700,216 @@
.eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
item.setTargetSlot(0);
//娓呯┖浠诲姟琛ㄦ暟鎹�
- bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item);
+// bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item);
}
//娓呯┖鍚姩鐘舵��
//鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
- //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
- List<ReadWriteEntity> list = new ArrayList<>();
- for (int i = 1; i <= 6; i++) {
- list.add(generateReadWriteEntity("DLP2A.DLP2A.TO" + i, 0));
- }
- list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 0));
- miloService.writeToOpcWord(list);
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setTo1(0);
+ s7DataZKDLPOne.setTo2(0);
+ s7DataZKDLPOne.setTo3(0);
+ s7DataZKDLPOne.setTo4(0);
+ s7DataZKDLPOne.setTo5(0);
+ s7DataZKDLPOne.setTo6(0);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
+ s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setMesReply(0);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
}
@Scheduled(fixedDelay = 1000)
public void finishOutBigStorageTask() throws Exception {
- ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
- if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
- log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫瀹屾垚鍑虹墖浠诲姟");
- return;
- }
- //鑾峰彇杩涚墖浠诲姟琛�
- List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
- if (CollectionUtil.isEmpty(outTaskList)) {
- log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫瀹屾垚杩涚墖浠诲姟");
- return;
- }
- List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
- if (CollectionUtil.isNotEmpty(unFinishTaskList)) {
- log.info("瀛樺湪鏈畬鎴愮殑鐜荤拑淇℃伅,鐜荤拑锛歿}", unFinishTaskList);
- return;
- }
- Map<Integer, List<BigStorageCageTask>> taskMap = outTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState));
- int taskType = 0;
- if (Const.OUT_TARGET_POSITION_ALL.contains(outTaskList.get(0).getTargetSlot())) {
- taskType = Const.BIG_STORAGE_AFTER_OUT;
- } else {
- taskType = Const.BIG_STORAGE_AFTER_DISPATCH;
- }
- //鎸夌収浠诲姟鐘舵�佷慨鏀瑰ぇ鐞嗙墖绗煎唴鐨勭幓鐠冩暟鎹�
-// 閲嶆柊璁＄畻澶х悊鐗囩鍐呯殑鍓╀綑灏哄
- Integer finalTaskType = taskType;
- taskMap.forEach((e1, v) -> {
- if (e1 == 2) {
- //杩涚墖瀹屾垚
- log.info("3銆佽幏鍙栬繘鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", v);
- List<Integer> outSuccessGlassSlot = new ArrayList<>();
- if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
- outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
- } else {
- List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
- List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
- outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
- outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
- }
- List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
- UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO();
- storageCageDTO.setGlassId(e.getGlassId());
- if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
- storageCageDTO.setTargetSlot(e.getStartSlot());
- } else {
- storageCageDTO.setTargetSlot(e.getTargetSlot());
- }
- return storageCageDTO;
- }).collect(Collectors.toList());
- if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
- hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
- } else {
- hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
- //鎸夌収鏍煎瓙淇℃伅鏇存柊瀵瑰簲鐨勮澶噄d
- List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
- hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
- }
- log.info("4銆佸ぇ鐞嗙墖绗艰繘鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", v);
- updateSlotRemainBySlots(outSuccessGlassSlot);
- } else if (e1 == 3) {
- //鐮存崯澶勭悊
- dealDamageOutTask(v);
- } else {
- //娓呯┖鐞嗙墖绗肩┖鏁版嵁
- noDealOutTask(v);
- }
- });
-
- for (BigStorageCageTask item : outTaskList) {
- //鏇存柊鍘嗗彶浠诲姟琛ㄤ腑鐨勪换鍔＄姸鎬�
- hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>()
- .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState())
- .eq(HollowBigStorageCageHistoryTask::getTaskType, taskType)
- .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
- //鏇存柊涓┖灏忕墖琛�
- Integer taskState = item.getTaskState();
- if (taskState == 2) {
- hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
- .set(HollowGlassQueueInfo::getState, Const.TEMPERING_OUT).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
- } else if (taskState == 3) {
-// temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
- hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
- .set(HollowGlassQueueInfo::getState, Const.TEMPERING_DAMAGE).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
-
- } else {
-// 绌烘墽琛�
- }
- }
try {
- //鏇存柊鏁伴噺
- //鎸夌収鐜荤拑id鑾峰彇闇�瑕佸嚭鐗囧鍒楄〃涓殑鏁版嵁
- if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
- HollowGlassQueueInfo hollowGlassQueueInfo = hollowGlassQueueInfoService.getOne(new LambdaQueryWrapper<HollowGlassQueueInfo>()
- .eq(HollowGlassQueueInfo::getGlassId, outTaskList.get(0).getGlassId())
- .orderByDesc(HollowGlassQueueInfo::getUpdateTime).last("limit 1"));
- List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
- .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassQueueInfo.getFlowCardId())
- .eq(HollowGlassQueueInfo::getCell, hollowGlassQueueInfo.getCell())
-// .eq(HollowGlassQueueInfo::getIsPair, 1)
- .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
- );
- if (CollectionUtil.isEmpty(list)) {
-// 浠诲姟鏇存柊涓哄凡瀹屾垚
- hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
- .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
- .eq("cell", hollowGlassQueueInfo.getCell())
- .setSql("pair_quantity = total_pair_quantity")
- .set("state", Const.HOLLOW_FLOW_CARD_SUCCESS)
- );
+ S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
+ Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
+ if (true != inkageEntity) {
+ log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫瀹屾垚鍑虹墖浠诲姟");
+ return;
+ }
+ //鑾峰彇鍑虹墖浠诲姟琛�
+ List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
+ if (CollectionUtil.isEmpty(outTaskList)) {
+ log.info("褰撳墠澶ц溅鏃犲嚭鐗囩幓鐠冿紝缁撴潫瀹屾垚鍑虹墖浠诲姟");
+ return;
+ }
+ log.info("涓┖鐞嗙墖绗煎嚭鐗囧畬鎴愪换鍔�:{}", outTaskList);
+ log.info("涓┖鐞嗙墖绗煎嚭鐗囨眹鎶ユ儏鍐�:{}", s7DataZKDLPTwo);
+ List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
+ if (CollectionUtil.isNotEmpty(unFinishTaskList)) {
+ log.info("瀛樺湪鏈畬鎴愮殑鐜荤拑淇℃伅,鐜荤拑锛歿}", unFinishTaskList);
+ return;
+ }
+ Map<Integer, List<BigStorageCageTask>> taskMap = outTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState));
+ int taskType = 0;
+ if (Const.OUT_TARGET_POSITION_ALL.contains(outTaskList.get(0).getTargetSlot())) {
+ taskType = Const.BIG_STORAGE_AFTER_OUT;
+ } else {
+ taskType = Const.BIG_STORAGE_AFTER_DISPATCH;
+ }
+ //鎸夌収浠诲姟鐘舵�佷慨鏀瑰ぇ鐞嗙墖绗煎唴鐨勭幓鐠冩暟鎹�
+// 閲嶆柊璁＄畻澶х悊鐗囩鍐呯殑鍓╀綑灏哄
+ Integer finalTaskType = taskType;
+ taskMap.forEach((e1, v) -> {
+ if (e1 == 2) {
+ //杩涚墖瀹屾垚
+ log.info("3銆佽幏鍙栧嚭鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", v);
+ List<Integer> outSuccessGlassSlot = new ArrayList<>();
+ if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
+ outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
+ } else {
+ List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
+ List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
+ outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
+ outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
+ }
+ List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
+ UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO();
+ storageCageDTO.setGlassId(e.getGlassId());
+ if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
+ storageCageDTO.setTargetSlot(e.getStartSlot());
+ } else {
+ storageCageDTO.setTargetSlot(e.getTargetSlot());
+ }
+ return storageCageDTO;
+ }).collect(Collectors.toList());
+ if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
+ hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
+ } else {
+ hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
+ //鎸夌収鏍煎瓙淇℃伅鏇存柊瀵瑰簲鐨勮澶噄d
+ List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
+ hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
+ }
+ log.info("4銆佸ぇ鐞嗙墖绗煎嚭鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", v);
+ updateSlotRemainBySlots(outSuccessGlassSlot);
+ } else if (e1 == 3) {
+ //鐮存崯澶勭悊
+ dealDamageOutTask(v);
} else {
-// 璁＄畻鍓╀綑鐜荤拑瀵规暟锛岀敤浠诲姟鎬婚槦鏁板噺鍓╀綑瀵规暟
- int remainCount = list.size() / hollowGlassQueueInfo.getTotalLayer();
- hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
- .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
- .eq("cell", hollowGlassQueueInfo.getCell())
- .setSql("pair_quantity = total_pair_quantity -" + remainCount)
- );
+ //娓呯┖鐞嗙墖绗肩┖鏁版嵁
+ noDealOutTask(v);
+ }
+ });
+
+ for (BigStorageCageTask item : outTaskList) {
+ //鏇存柊鍘嗗彶浠诲姟琛ㄤ腑鐨勪换鍔＄姸鎬�
+ hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>()
+ .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState())
+ .eq(HollowBigStorageCageHistoryTask::getTaskType, taskType)
+ .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
+ //鏇存柊涓┖灏忕墖琛�
+ Integer taskState = item.getTaskState();
+ if (taskState == 2) {
+ hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
+ .set(HollowGlassQueueInfo::getState, Const.TEMPERING_OUT).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
+ } else if (taskState == 3) {
+// temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
+ hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
+ .set(HollowGlassQueueInfo::getState, Const.TEMPERING_DAMAGE).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
+
+ } else {
+// 绌烘墽琛�
}
}
- } catch (Exception e) {
- log.info("璁＄畻鐜荤拑鏁伴噺杩囩▼涓嚭鐜伴敊璇紝閿欒淇℃伅{}", e.getMessage());
- }
+ try {
+ //鏇存柊鏁伴噺
+ //鎸夌収鐜荤拑id鑾峰彇闇�瑕佸嚭鐗囧鍒楄〃涓殑鏁版嵁
+ if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
+ HollowGlassQueueInfo hollowGlassQueueInfo = hollowGlassQueueInfoService.getOne(new LambdaQueryWrapper<HollowGlassQueueInfo>()
+ .eq(HollowGlassQueueInfo::getGlassId, outTaskList.get(0).getGlassId())
+ .orderByDesc(HollowGlassQueueInfo::getUpdateTime).last("limit 1"));
+ List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
+ .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassQueueInfo.getFlowCardId())
+ .eq(HollowGlassQueueInfo::getCell, hollowGlassQueueInfo.getCell())
+// .eq(HollowGlassQueueInfo::getIsPair, 1)
+ .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
+ );
+ if (CollectionUtil.isEmpty(list)) {
+// 浠诲姟鏇存柊涓哄凡瀹屾垚
+ hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
+ .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
+ .eq("cell", hollowGlassQueueInfo.getCell())
+ .setSql("pair_quantity = total_pair_quantity")
+ .set("state", Const.HOLLOW_FLOW_CARD_SUCCESS)
+ );
+ } else {
+// 璁＄畻鍓╀綑鐜荤拑瀵规暟锛岀敤浠诲姟鎬婚槦鏁板噺鍓╀綑瀵规暟
+ int remainCount = list.size() / hollowGlassQueueInfo.getTotalLayer();
+ hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
+ .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
+ .eq("cell", hollowGlassQueueInfo.getCell())
+ .setSql("pair_quantity = total_pair_quantity -" + remainCount)
+ );
+ }
+ }
+ } catch (Exception e) {
+ log.info("璁＄畻鐜荤拑鏁伴噺杩囩▼涓嚭鐜伴敊璇紝閿欒淇℃伅{}", e.getMessage());
+ }
// 閲嶇疆浠诲姟琛ㄦ暟鎹�
- bigStorageCageTaskService.updateOutTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
+ resetOutTask();
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ s7DataZKDLPTwo = new S7DataZKDLPTwo();
+ s7DataZKDLPTwo.setMesReply(0);
+ s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
+ } catch (Exception e) {
+ log.info("涓┖鐞嗙墖绗煎嚭鐗囨眹鎶ヤ换鍔″紓甯革細{}", e);
+ }
- //娓呯┖鍚姩鐘舵��
- //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 0));
}
+
+ @Scheduled(fixedDelay = 1000)
+ public void inCarTask() {
+ //璇诲彇鍗忚鏁版嵁
+ S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
+ log.info("杩涚墖浠诲姟璇诲彇s7DataZKDLPOne:{}", s7DataZKDLPOne);
+ Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
+ if (!inkageEntity) {
+ log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫杩涚墖浠诲姟");
+ return;
+ }
+ if (StringUtils.isNotBlank(s7DataZKDLPOne.getId1())) {
+ //姹囨姤瀛椾负1 鍚姩瀛椾负1鏄� 娓呴櫎鎵�鏈変换鍔′俊鎭�
+ if (s7DataZKDLPOne.getId1().equals(s7DataZKDLPOne.getId1())) {
+ //todo:娓呯┖浠诲姟
+ s7DataZKDLPOne.setFrom1(0);
+ s7DataZKDLPOne.getId1();
+ }
+ log.info("瀛樺湪浠诲姟锛岀粨鏉�");
+ return;
+ }
+ Integer requestEntity = s7DataZKDLPOne.getRequestMes();
+ if (1 != requestEntity) {
+ log.info("褰撳墠鏈敹鍒拌繘鐗囪姹傦紝缁撴潫杩涚墖浠诲姟");
+ return;
+ }
+ //鏈夎姹備俊鍙�
+ List<String> glassIdList = hollowGlassQueueInfoService.queryNeedInCarGlass();
+ if (CollectionUtil.isEmpty(glassIdList)) {
+ return;
+ }
+ int count = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
+ .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT));
+ if (count > 0) {
+ return;
+ }
+ List<HollowBigStorageCageDetails> list = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
+ .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .in(HollowBigStorageCageDetails::getDeviceId, 5)
+ .in(HollowBigStorageCageDetails::getGlassId, glassIdList));
+ if (CollectionUtil.isEmpty(list)) {
+ return;
+ }
+ HollowBigStorageCageDetails details = list.get(0);
+ //todo:鐢熸垚杩涜繘鐗囧ぇ杞︿换鍔�
+ hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
+ .set(HollowBigStorageCageDetails::getState, Const.RAW_GLASS_STATE_OUT)
+ .eq(HollowBigStorageCageDetails::getGlassId, details.getGlassId()));
+
+ }
+
private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
// 鑾峰彇杩涚墖浠诲姟琛ㄤ腑鐘舵�佷负鐮存崯鐨勬暟鎹�
@@ -748,7 +988,7 @@
List<String> glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
.set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
- .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
+ .notIn(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
.in(HollowBigStorageCageDetails::getGlassId, glassList));
} else {
@@ -757,7 +997,7 @@
hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
.set(HollowBigStorageCageDetails::getSlot, item.getStartSlot())
.set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
- .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
+ .notIn(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
.eq(HollowBigStorageCageDetails::getGlassId, item.getGlassId()));
}
}
@@ -804,7 +1044,10 @@
if (null == storageCage) {
//鍚憄lc鍙戦�佹姤璀�:鐩撮�氱墖鍙板瓨鍦ㄧ幓鐠冿紝鏃犳硶缁х画鐩撮��
- miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
+// miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
+ S7DataZKDLPOne s7DataZKDLPOne = new S7DataZKDLPOne();
+ s7DataZKDLPOne.setAlramSignal(16);
+ s7SerializerZKDLPOne.write(s7DataZKDLPOne);
Assert.isFalse(storageCage == null, "浠诲姟璋冨害娌℃湁澶氫綑鏍煎瓙锛岀粨鏉熻皟搴︿换鍔�");
}
@@ -836,7 +1079,8 @@
//鎵撹溅鍓╀綑灏哄
Integer remainWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_OUT_CAR_SIZE);
- Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
+// Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
+ Integer glassGap = hollowGlassRelationInfoService.getGlassGapByThickness(list.get(0).getThickness());
for (T e : list) {
if (templist.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
break;
@@ -863,10 +1107,19 @@
}
baseInfoList = resultList;
} else {
- //澶т簬鎬诲眰鏁板厛鍙杢otalLyaer鍊嶆暟鏁伴噺鐨勭幓鐠冿紝淇濊瘉澶ц溅涓婄殑鐜荤拑鎴愬浼�
+ //澶т簬鎬诲眰鏁板厛鍙杢otalLayer鍊嶆暟鏁伴噺鐨勭幓鐠冿紝淇濊瘉澶ц溅涓婄殑鐜荤拑鎴愬浼�
int remainCount = templist.size() % totalLayer;
if (targetSlot == 930) {
- baseInfoList = templist.subList(0, totalLayer);
+ int tempSequence = templist.get(0).getHollowSequence();
+ List<T> resultList = new ArrayList<>();
+ for (int i = 0; i < templist.size(); i++) {
+ if (tempSequence == list.get(i).getHollowSequence()) {
+ resultList.add(templist.get(i));
+ } else {
+ break;
+ }
+ }
+ baseInfoList = resultList;
} else {
baseInfoList = templist.subList(0, templist.size() - remainCount);
}
@@ -880,12 +1133,53 @@
for (T t : baseInfoList) {
bigStorageCageTaskList.add(new BigStorageCageTask(t.getGlassId(), t.getSlot(), targetSlot, 0));
}
- while (bigStorageCageTaskList.size() < 6) {
- bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
- }
//娓呯┖浠诲姟琛ㄦ暟鎹�
- bigStorageCageTaskService.removeAll(tableName);
- bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
+ resetOutTask();
+ log.info("鐢熸垚鍑虹墖浠诲姟鏁版嵁{}", bigStorageCageTaskList);
+ S7DataZKDLPTwo s7DataZKDLPTwo = new S7DataZKDLPTwo();
+ for (int i = 0; i < bigStorageCageTaskList.size() && i < 6; i++) {
+ String glassId = bigStorageCageTaskList.get(i).getGlassId();
+ Integer startSlot = bigStorageCageTaskList.get(i).getStartSlot();
+ Integer target = bigStorageCageTaskList.get(i).getTargetSlot();
+ if (startSlot > 0) {
+ switch (i) {
+ case 0:
+ s7DataZKDLPTwo.setId1(glassId);
+ s7DataZKDLPTwo.setFrom1(startSlot);
+ s7DataZKDLPTwo.setTo1(target);
+ break;
+ case 1:
+ s7DataZKDLPTwo.setId2(glassId);
+ s7DataZKDLPTwo.setFrom2(startSlot);
+ s7DataZKDLPTwo.setTo2(target);
+ break;
+ case 2:
+ s7DataZKDLPTwo.setId3(glassId);
+ s7DataZKDLPTwo.setFrom3(startSlot);
+ s7DataZKDLPTwo.setTo3(target);
+ break;
+ case 3:
+ s7DataZKDLPTwo.setId4(glassId);
+ s7DataZKDLPTwo.setFrom4(startSlot);
+ s7DataZKDLPTwo.setTo4(target);
+ break;
+ case 4:
+ s7DataZKDLPTwo.setId5(glassId);
+ s7DataZKDLPTwo.setFrom5(startSlot);
+ s7DataZKDLPTwo.setTo5(target);
+ break;
+ case 5:
+ s7DataZKDLPTwo.setId6(glassId);
+ s7DataZKDLPTwo.setFrom6(startSlot);
+ s7DataZKDLPTwo.setTo6(target);
+ break;
+ }
+ }
+ }
+ s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
+ log.info("鍑虹墖浠诲姟鍐欏叆鏁版嵁{}", s7DataZKDLPTwo);
+ S7DataZKDLPTwo s7DataZKDLPTwo1 = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
+ log.info("鍐欏叆鍑虹墖浠诲姟鍚庤鍙栨暟鎹畕}", s7DataZKDLPTwo1);
List<HollowBigStorageCageHistoryTask> historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> {
HollowBigStorageCageHistoryTask history = new HollowBigStorageCageHistoryTask();
BeanUtils.copyProperties(e, history);
@@ -893,15 +1187,18 @@
history.setTaskType(taskType);
return history;
}).collect(Collectors.toList());
+ log.info("鍘嗗彶浠诲姟淇濆瓨{}", historyList);
hollowBigStorageCageHistoryTaskService.saveBatch(historyList);
log.info("灏嗗嚭鐗囩幓鐠儃}鐜荤拑鐘舵�佹敼涓哄嚭鐗囦腑", glassIds);
hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
.set(HollowBigStorageCageDetails::getState, state)
.set(Const.BIG_STORAGE_AFTER_DISPATCH.equals(taskType), HollowBigStorageCageDetails::getSlot, targetSlot)
- .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
+ .notIn(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
.in(HollowBigStorageCageDetails::getGlassId, glassIds));
try {
- miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 1));
+ s7DataZKDLPTwo = new S7DataZKDLPTwo();
+ s7DataZKDLPTwo.setMesReply(1);
+ s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
} catch (Exception e) {
e.printStackTrace();
}
@@ -918,9 +1215,6 @@
Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
//瀛樺湪 灏嗘牸瀛愬唴鐨勭幓鐠冨垎鍒繘琛屾洿鏂�
-// List<HollowBigStorageCage> hollowBigStorageCageList = hollowBigStorageCageService.list(new LambdaQueryWrapper<HollowBigStorageCage>()
-// .lt(HollowBigStorageCage::getRemainWidth, 0).in(HollowBigStorageCage::getSlot, slotList));
-// List<Integer> resultSlotList = hollowBigStorageCageList.stream().map(HollowBigStorageCage::getSlot).collect(Collectors.toList());
slotRemainMap = inSlotGlassList.stream()
.collect(Collectors.groupingBy(HollowBigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));
slotRemainMap.forEach((e, v) -> {
@@ -945,4 +1239,54 @@
.value(value)
.build();
}
+
+ //璇诲彇鍑虹墖鍦板潃
+ private List<BigStorageCageTask> getOutTaskList(S7DataZKDLPTwo s7DataZKDLPTwo) {
+ List<BigStorageCageTask> outTaskList = new ArrayList<>();
+ List<String> glassIds = s7DataZKDLPTwo.getIds();
+ List<Integer> startSlots = s7DataZKDLPTwo.getFroms();
+ List<Integer> endSlots = s7DataZKDLPTwo.getTos();
+ List<Integer> states = s7DataZKDLPTwo.getStates();
+ for (int i = 0; i < 6; i++) {
+ if (glassIds.get(i) != null && !glassIds.get(i).isEmpty()) {
+ BigStorageCageTask bigStorageCageTask = new BigStorageCageTask();
+ bigStorageCageTask.setGlassId(glassIds.get(i));
+ bigStorageCageTask.setStartSlot(startSlots.get(i));
+ bigStorageCageTask.setTargetSlot(endSlots.get(i));
+ bigStorageCageTask.setTaskState(states.get(i));
+ outTaskList.add(bigStorageCageTask);
+ }
+ }
+ return outTaskList;
+ }
+
+ //閲嶇疆浠诲姟琛�
+ private void resetOutTask() {
+ S7DataZKDLPTwo s7DataZKDLPTwo = new S7DataZKDLPTwo();
+ s7DataZKDLPTwo.setId1("");
+ s7DataZKDLPTwo.setId2("");
+ s7DataZKDLPTwo.setId3("");
+ s7DataZKDLPTwo.setId4("");
+ s7DataZKDLPTwo.setId5("");
+ s7DataZKDLPTwo.setId6("");
+ s7DataZKDLPTwo.setFrom1(0);
+ s7DataZKDLPTwo.setFrom2(0);
+ s7DataZKDLPTwo.setFrom3(0);
+ s7DataZKDLPTwo.setFrom4(0);
+ s7DataZKDLPTwo.setFrom5(0);
+ s7DataZKDLPTwo.setFrom6(0);
+ s7DataZKDLPTwo.setTo1(0);
+ s7DataZKDLPTwo.setTo2(0);
+ s7DataZKDLPTwo.setTo3(0);
+ s7DataZKDLPTwo.setTo4(0);
+ s7DataZKDLPTwo.setTo5(0);
+ s7DataZKDLPTwo.setTo6(0);
+ s7DataZKDLPTwo.setState1(0);
+ s7DataZKDLPTwo.setState2(0);
+ s7DataZKDLPTwo.setState3(0);
+ s7DataZKDLPTwo.setState4(0);
+ s7DataZKDLPTwo.setState5(0);
+ s7DataZKDLPTwo.setState6(0);
+ s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
+ }
}
\ No newline at end of file
--
Gitblit v1.8.0