YiWuProject.git

			@@ -1,379 +1,1162 @@
			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.mes.bigstorage.entity.BigStorageCageDetails;
			import com.mes.bigstorage.entity.BigStorageDTO;
			import com.mes.bigstorage.service.BigStorageCageDetailsService;
			import com.mes.bigstorage.service.BigStorageCageService;
			import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
			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.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 org.springframework.util.CollectionUtils;

			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.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 {
			//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.conditions.update.LambdaUpdateWrapper;
			//import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
			//import com.github.yulichang.toolkit.JoinWrappers;
			//import com.github.yulichang.wrapper.MPJLambdaWrapper;
			//import com.mes.base.entity.BigStorageCageBaseInfo;
			//import com.mes.bigstorage.entity.BigStorageCage;
			//import com.mes.bigstorage.entity.BigStorageCageDetails;
			//import com.mes.bigstorage.entity.dto.BigStorageDTO;
			//import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
			//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.entity.UpdateBigStorageCageDTO;
			//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.damage.entity.Damage;
			//import com.mes.damage.service.DamageService;
			//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 com.mes.tools.S7control;
			//import com.mes.utils.RedisUtil;
			//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.stereotype.Component;
			//
			//import javax.annotation.Resource;
			//import java.util.*;
			//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;
			// @Resource
			// private DamageService damageService;
			//
			// @Resource
			// private RedisUtil redisUtil;
			//
			// private static final String REQUEST_WORD = "1";
			//
			// @Value("${mes.sequence.order}")
			// private boolean sequenceOrder;
			//
			// @Value("${mes.carWidth}")
			// private Integer carWidth;
			//
			// @Value("${mes.slotWidth}")
			// private Integer slotWidth;
			//
			// @Value("${mes.inCarMaxSize}")
			// private Integer inCarMaxSize;
			//
			// @Value("${mes.outCarMaxSize}")
			// private Integer outCarMaxSize;
			//
			// @Value("${mes.glassGap}")
			// private Integer glassGap;
			//
			// @Value("${mes.xMaxSize}")
			// private Integer xMaxSize;
			//
			//
			// private String d01GlassId = "";
			// private String d04GlassId = "";
			//
			// // @Scheduled(fixedDelay = 300)
			// public void plcToHomeEdgScan() {
			// Date startDate = new Date();
			// log.info("大理片笼扫码任务开始执行时间：{}", startDate);
			// PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
			// try {
			// String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
			// String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
			// //D02id判断是否为空确认是否空闲允许进片
			// String d02State = plcParameterObject.getPlcParameter("D02ID").getValue();
			// String d03State = plcParameterObject.getPlcParameter("D03State").getValue();
			// String d05State = plcParameterObject.getPlcParameter("D05State").getValue();
			// String mesD01Value = plcParameterObject.getPlcParameter("MESToD01").getValue();
			// String mesD04Value = plcParameterObject.getPlcParameter("MESToD04").getValue();
			// String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
			// String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
			// String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
			// String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();
			//
			// String plcFeedGlassid = "";
			// String plcFeedReqLine = "0";
			// if ("1".equals(plcParameterObject.getPlcParameter("D01Request").getValue())) {
			// plcFeedReqLine = "1";
			// plcFeedGlassid = plcParameterObject.getPlcParameter("D01ID1").getValue();
			// log.info("1、获取d01Id扫描ID为：{}，请求字为{};获取d04Id扫描ID为：{}，请求字为{};", d01Id, d01ToMES, d04Id, d04ToMES);
			// if (StringUtils.isBlank(d01ToMES) && StringUtils.isBlank(d04ToMES)) {
			// log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
			// return;
			// }
			// if (REQUEST_WORD.equals(d03State) && REQUEST_WORD.equals(d05State)) {
			// log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务");
			// return;
			// }
			// //按照线路及玻璃id获取相邻两块玻璃卧转立上的玻璃: 状态为0不操作（D01送片，0不操作，1允许送片），请求字为1，（02玻璃id为空或者卧转立未启动）
			// if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) \|\| !REQUEST_WORD.equals(d03State))) {
			// List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
			// new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .gt(BigStorageCageFeedTask::getTargetSlot, 0)
			// .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
			// );
			// if (CollectionUtils.isEmpty(bigStorageCageFeedTasks)) {
			// if (!d01GlassId.equals(d01Id)) {
			// judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
			// edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
			// .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d01Id));
			//// d01GlassId = d01Id;
			// }
			// }
			// if ("1".equals(plcParameterObject.getPlcParameter("D04Request").getValue())) {
			// plcFeedReqLine = "2";
			// plcFeedGlassid = plcParameterObject.getPlcParameter("D04ID1").getValue();
			// }
			//// 状态为0不操作（D01送片，0不操作，1允许送片），请求字为1，卧转立未启动
			// if (!REQUEST_WORD.equals(mesD04Value) && REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) {
			// List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
			// new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .gt(BigStorageCageFeedTask::getTargetSlot, 0)
			// .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
			// );
			// if (CollectionUtils.isEmpty(bigStorageCageFeedTasks)) {
			// if (!d04GlassId.equals(d04Id)) {
			// judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
			// edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
			// .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));
			//// d04GlassId = d04Id;
			// }
			// }
			// 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;
			// }
			// }
			// Date endDate = new Date();
			// log.info("大理片笼扫码任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// }
			//
			// // @Scheduled(fixedDelay = 300)
			// public void plcToHomeEdgFreeCarTask() {
			// Date startDate = new Date();
			// log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
			// PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
			// String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getValue();
			// String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getValue();
			// log.info("MESToD03:{},MESToD05:{}", mesD03Address, mesD05Address);
			// if ("2".equals(mesD03Address) \|\| "2".equals(mesD05Address)) {
			// log.info("有启动信号，MESToD03:{},MESToD05:{}", mesD03Address, mesD05Address);
			// }
			// PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
			// String e01Status = plcParameterObject.getPlcParameter("E01State").getValue();
			// String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
			// String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
			// log.info("执行空车送片任务，获取到的大车状态为{}，卧转立状态分别为d03:{}，d05:{}", e01Status, d03ToMES, d05ToMES);
			// List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
			// new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .ne(BigStorageCageFeedTask::getTargetSlot, 0)
			// .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
			// );
			// if (bigStorageCageFeedTasks.size() > 0) {
			// Date endDate = new Date();
			// log.info("大车有正在执行的任务{}，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", bigStorageCageFeedTasks, endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// if (REQUEST_WORD.equals(e01Status)) {
			// Date endDate = new Date();
			// log.info("进片大车非空闲，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
			// Date endDate = new Date();
			// log.info("卧转立第一次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
			// Date endDate = new Date();
			// log.info("卧转立第二次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			//// List<Integer> lines=new ArrayList<>();
			//// if(REQUEST_WORD.equals(d03ToMES)){
			//// lines.add(Const.A09_OUT_TARGET_POSITION);
			//// }
			//// if(REQUEST_WORD.equals(d05ToMES)){
			//// lines.add(Const.A10_OUT_TARGET_POSITION);
			//// }
			// LambdaQueryWrapper<BigStorageCageFeedTask> wrapper = new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .eq(BigStorageCageFeedTask::getTaskType, Const.BIG_STORAGE_IN_RUN)
			// .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP);
			//// .in(BigStorageCageFeedTask::getLine,lines);
			// //获取可以启动卧转立的任务线路
			// List<BigStorageCageFeedTask> feedTaskList = bigStorageCageFeedTaskService.list(wrapper);
			// if (CollectionUtils.isNotEmpty(feedTaskList)) {
			// if (feedTaskList.size() == 1) {
			// computeTargetByLine(feedTaskList.get(0).getLine());
			// } else {
			// //比较最早一片任务的版图id及版序求出卧转立的线路
			// Integer startLine = getStartLine();
			//// //计算目标格子，发送启动任务
			// computeTargetByLine(startLine);
			// }
			// Date endDate = new Date();
			// log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
			// String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
			// log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
			// //获取两条线卧转立是否有玻璃，且任务状态为1/2
			// List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
			// if (CollectionUtils.isEmpty(lineList)) {
			// Date endDate = new Date();
			// log.info("两条线卧转立为空或者有进片任务未完成，结束任务，大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// Integer lineFirst = lineList.get(0);
			// String lineGlassId = lineFirst.equals(Const.A09_OUT_TARGET_POSITION) ? d01Id : d04Id;
			// //仅有一条先符合启动启动条件
			// if (lineList.size() == 1) {
			// //如果进片请求但玻璃为空，计算任务表进片格子发送进片任务
			// if (StringUtils.isEmpty(lineGlassId)) {
			// computeTargetByLine(lineFirst);
			// } else {
			// //todo:计算扫描到的玻璃是否可以存进卧转立
			// //获取卧转立剩余宽度
			// if (computeIsRun(lineFirst, lineGlassId)) {
			// computeTargetByLine(lineFirst);
			// } 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);
			// }
			// log.info("当前线路：{}，有扫码玻璃：{}", lineFirst, lineGlassId);
			// }
			// }
			// Date endDate = new Date();
			// log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// //两条先均可执行进片任务，判断两条线是否进片请求是否都为空
			// if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
			// //比较最早一片任务的版图id及版序求出卧转立的线路
			// Integer line = getStartLine();
			// //计算任务表进片格子发送进片任务
			// computeTargetByLine(line);
			// Date endDate = new Date();
			// log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// } else if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
			//// todo:两个都有进片玻璃
			// if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id) && computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
			// //比较最早一片任务的版图id及版序求出卧转立的线路
			// Integer line = getStartLine();
			// //计算任务表进片格子发送进片任务
			// computeTargetByLine(line);
			// } else if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id)) {
			// computeTargetByLine(Const.A09_OUT_TARGET_POSITION);
			// } else if (computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
			// computeTargetByLine(Const.A10_OUT_TARGET_POSITION);
			// } 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);
			// Date endDate = new Date();
			// log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// } else {
			// //，或者仅有一条有玻璃
			// //一条线为空，一条线有进片请求有玻璃
			// int outLine = StringUtils.isBlank(d01Id) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
			// //获取进片请求玻璃为空的，计算任务表进片格子发送进片任务
			// computeTargetByLine(outLine);
			// }
			// Date endDate = new Date();
			// log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// }
			//
			// // @Scheduled(fixedDelay = 10000)
			// public void plcToHomeEdgOutTask() {
			// Date startDate = new Date();
			// log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
			// PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
			// String e02State = plcMesObject.getPlcParameter("E02State").getValue();
			// if (REQUEST_WORD.equals(e02State)) {
			// log.info("出片忙碌，结束出片任务");
			// return;
			// }
			// String mesToPLCAddress = plcMesObject.getPlcParameter("MESToPLC").getAddress();
			// List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
			// .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
			// if (CollectionUtils.isNotEmpty(outingList)) {
			// log.info("有正在执行出片的任务，结束当前出片线程");
			// return;
			// }
			// if (redisUtil.getCacheObject("temperingSwitch")) {
			// //是否有正在钢化的玻璃
			// List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
			// .selectAll(TemperingGlassInfo.class)
			// .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
			// .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
			// .isNull(BigStorageCageOutTask::getGlassId)
			// .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
			// if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
			// log.info("有正在出片的钢化任务");
			// computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
			// Date endDate = new Date();
			// log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// //是否有人工下片任务有直接出
			//// List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
			//// .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
			// List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)
			// .orderByAsc(BigStorageCageDetails::getSlot)
			// .orderByDesc(BigStorageCageDetails::getId));
			// if (CollectionUtils.isNotEmpty(artificialList)) {
			// computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
			// Date endDate = new Date();
			// log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// //钢化优先：获取理片笼玻璃小片破损表数量判断笼内版图是否到齐
			// List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
			// if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
			// //玻璃到齐包括已出片的
			// //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务结束
			// for (TemperingLayoutDTO item : temperingLayoutDTOList) {
			// if (redisUtil.getCacheObject("temperingengineerId").equals(item.getEngineerId())) {
			// List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
			// .selectAll(GlassInfo.class)
			// .select("-1 as state")
			// .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
			// .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
			// .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
			// .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
			// .eq(GlassInfo::getEngineerId, item.getEngineerId())
			// .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
			// if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
			// temperingGlassInfoService.saveBatch(temperingGlassInfos);
			// computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
			// Date endDate = new Date();
			// log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// }
			// }
			// }
			//
			// //查询出片表是否有任务未完成的任务
			// List<BigStorageCageOutTask> bigStorageCageOutTask = bigStorageCageOutTaskService.querybigStorageCageOutTask(0);
			// if (bigStorageCageOutTask.size() == 0) {
			// boolean result = bigStorageCageService.outGlass();
			// log.info("8、没有未完成任务时调用出片接口");
			// if (result == false) {
			// temperingGlassInfoService.schedulingTask();
			// }
			// //执行内部调度任务
			// List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
			// if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
			// loop:
			// for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
			// List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
			// for (int i = 0; i < slotSequenceList.size() - 1; i++) {
			// SlotSequenceDTO first = slotSequenceList.get(i);
			// SlotSequenceDTO second = slotSequenceList.get(i + 1);
			// int slotWidth = carWidth - first.getRemainWidth() - glassGap;
			// if (first.getMinSequence() == second.getMaxSequence() + 1
			// && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
			// List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
			// .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
			// if (CollectionUtils.isNotEmpty(list)) {
			// List<BigStorageCageOutTask> outTasks = new ArrayList<>();
			// int serialNumber = 1;
			// for (BigStorageCageDetails item : list) {
			// outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
			// item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
			// }
			// //新增调度任务
			// bigStorageCageOutTaskService.saveBatch(outTasks);
			// //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
			// List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
			// bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
			// .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList));
			// //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
			// // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
			// updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
			// break loop;
			// }
			// }
			// }
			// }
			// 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();
			//// //向plc写入确认字
			//// int returnData = 0;
			//// int count = 1;
			//// while (returnData == 0) {
			//// log.info("已向plc第{}次送协议", count);
			//// S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
			//// returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
			//// log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
			//// }
			// Date endDate = new Date();
			// log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			// }
			@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);
			}

			/**
			* 按照玻璃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
			*/
			private 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.isTrue(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());
			}

			/**
			* 计算任务表进片线路的目标格子，并启动任务
			*/
			private 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<>();
			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.setTragetSlot(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);
			});
			//3、更新进片任务表
			boolean taskFlag = bigStorageCageFeedTaskService.updateBatchById(taskList);
			//4、在详情表中加入进片玻璃信息
			bigStorageCageDetailsService.saveBatch(bigStorageCageDetailsList);
			if (taskFlag) {
			String lineAddress = line.equals(Const.A09_OUT_TARGET_POSITION) ? d02GoAdress : d05GoAdress;
			S7object.getinstance().plccontrol.writeWord(lineAddress, (short) 1);
			}
			return taskFlag;
			}
			}
			//
			// // @Scheduled(fixedDelay = 300)
			// public void updateInGlassStateTask() {
			// Date startDate = new Date();
			// log.info("1、大理片笼进片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
			// //因为大理片笼和出片任务是两个库的数据，所以要分开查找
			// List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW));
			// if (CollectionUtils.isNotEmpty(list)) {
			// log.info("2、获取所有正在进片的玻璃信息id:{}", list);
			// List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
			// List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .in(BigStorageCageFeedTask::getGlassId, glassIds)
			// .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT));
			// if (CollectionUtils.isNotEmpty(inSuccessGlass)) {
			// log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass);
			// List<Integer> inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList());
			// List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
			// UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
			// BeanUtils.copyProperties(e, storageCageDTO);
			// return storageCageDTO;
			// }).collect(Collectors.toList());
			// bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
			// log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlass);
			// //更新理片笼玻璃尺寸
			// updateSlotRemainBySlots(inSuccessGlassSlot);
			// log.info("5、大理片笼进片目标格子尺寸更新完成");
			// }
			//
			// }
			// Date endDate = new Date();
			// log.info("end:大理片笼进片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			//
			// }
			//
			// // @Scheduled(fixedDelay = 300)
			// public void updateOutGlassStateTask() {
			// Date startDate = new Date();
			// log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
			// //因为大理片笼和出片任务是两个库的数据，所以要分开查找
			// List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
			// if (CollectionUtils.isNotEmpty(list)) {
			// log.info("2、获取所有正在出片的玻璃信息id:{}", list);
			// List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
			// List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
			// .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
			// if (CollectionUtils.isNotEmpty(outSuccessGlass)) {
			// for (BigStorageCageOutTask bigStorageCageOutTask : outSuccessGlass
			// ) {
			// if (bigStorageCageOutTask.getEndSlot().equals(Const.ARTIFICIAL_OUT_TARGET_POSITION)) {
			// temperingGlassInfoService.update(
			// new LambdaUpdateWrapper<TemperingGlassInfo>()
			// .set(TemperingGlassInfo::getState, Const.TEMPERING_END)
			// .eq(TemperingGlassInfo::getGlassId, bigStorageCageOutTask.getGlassId())
			// );
			// }
			// }
			// log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass);
			// List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
			// UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
			// storageCageDTO.setGlassId(e.getGlassId());
			// storageCageDTO.setTargetSlot(e.getStartSlot());
			// return storageCageDTO;
			// }).collect(Collectors.toList());
			// bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
			// List<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList());
			// log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlass);
			// //更新理片笼玻璃尺寸
			// updateSlotRemainBySlots(outSuccessSlotList);
			// log.info("5、大理片笼进片目标格子尺寸更新完成");
			// }
			// }
			// Date endDate = new Date();
			// log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			//
			// }
			//
			// // @Scheduled(fixedDelay = 300)
			// public void updateScheduleGlassStateTask() {
			// Date startDate = new Date();
			// log.info("1、大理片笼调度完成后更新大理片笼数据任务开始执行时间：{}", startDate);
			// //因为大理片笼和调度任务是两个库的数据，所以要分开查找
			// List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING));
			// if (CollectionUtils.isNotEmpty(list)) {
			// log.info("2、获取所有正在出片的玻璃信息id:{}", list);
			// List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
			// List<BigStorageCageOutTask> scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
			// .in(BigStorageCageOutTask::getGlassId, glassIds).eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
			// .notIn(BigStorageCageOutTask::getEndSlot, Const.TEMPERING_OUT_TARGET_POSITION, Const.ARTIFICIAL_OUT_TARGET_POSITION));
			// if (CollectionUtils.isNotEmpty(scheduleSuccessGlass)) {
			// log.info("3、获取调度已完成的玻璃信息id:{}", scheduleSuccessGlass);
			// List<UpdateBigStorageCageDTO> storageCageDTOList = scheduleSuccessGlass.stream().map(e -> {
			// UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
			// storageCageDTO.setGlassId(e.getGlassId());
			// storageCageDTO.setTargetSlot(e.getEndSlot());
			// return storageCageDTO;
			// }).collect(Collectors.toList());
			// bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
			// List<String> scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
			// log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", scheduleSuccessGlassIds);
			// //更新理片笼玻璃尺寸
			// List<Integer> slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList());
			// slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList()));
			// updateSlotRemainBySlots(slotList);
			// log.info("5、大理片笼进片目标格子尺寸更新完成");
			// }
			// }
			// Date endDate = new Date();
			// log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			//
			// }
			//
			// /**
			// * 处理破损表任务
			// */
			//// @Scheduled(fixedDelay = 300)
			// public void dealDamageTask() {
			// Date startDate = new Date();
			// log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate);
			// //获取进片任务表中状态为破损的数据
			// List<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
			// if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) {
			// log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList);
			// bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
			// //理片笼详情表数据状态更新
			// bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
			// //将破损信息新增入破损表
			// List<Integer> slotList = new ArrayList<>();
			// for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
			// Damage damage = new Damage();
			// damage.setGlassId(bigStorageCageFeedTask.getGlassId());
			// damage.setLine(bigStorageCageFeedTask.getLine());
			// damage.setWorkingProcedure("磨边");
			// damage.setRemark("进笼前卧转立");
			// damage.setStatus(1);
			// damage.setType(bigStorageCageFeedTask.getTaskState());
			// damageService.insertDamage(damage);
			// slotList.add(bigStorageCageFeedTask.getTargetSlot());
			// }
			// //更新格子剩余宽度
			// updateSlotRemainBySlots(slotList);
			// log.info("进片任务执行完成");
			// }
			// //获取出片任务表中状态为破损的数据
			// List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
			// .in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
			// if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {
			// log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList);
			// bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
			// List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
			// //移除钢化下片表数据
			// temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));
			// //理片笼详情表数据状态删除
			// bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList));
			// //将破损信息新增入破损表
			// List<Integer> slotList = new ArrayList<>();
			// for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {
			// Damage damage = new Damage();
			// damage.setGlassId(bigStorageCageOutTask.getGlassId());
			// damage.setLine(bigStorageCageOutTask.getEndSlot());
			// damage.setWorkingProcedure("钢化");
			// damage.setRemark("出片后卧转立");
			// damage.setStatus(1);
			// damage.setType(bigStorageCageOutTask.getTaskState());
			// damageService.insertDamage(damage);
			// slotList.add(bigStorageCageOutTask.getStartSlot());
			// }
			// //更新格子剩余宽度
			// updateSlotRemainBySlots(slotList);
			// log.info("出片任务执行完成");
			// }
			// Date endDate = new Date();
			// log.info("大理片笼破损玻璃清除任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
			// return;
			// }
			//
			// /**
			// * 确认字清空
			// */
			//// @Scheduled(fixedDelay = 300)
			// public void confirmClear() {
			// PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
			// String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
			// String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();
			// String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
			// String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
			//// String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
			//// String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
			// String d03ToMES = plcParameterObject.getPlcParameter("D03Request").getValue();
			// String d05ToMES = plcParameterObject.getPlcParameter("D05Request").getValue();
			// String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
			// String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
			// if (!REQUEST_WORD.equals(d01ToMES)) {
			// log.info("地址：{}写入0", mesD01Address);
			// S7object.getinstance().plccontrol.writeWord(mesD01Address, 0);
			// }
			// if (!REQUEST_WORD.equals(d04ToMES)) {
			// log.info("地址：{}写入0", mesD04Address);
			// S7object.getinstance().plccontrol.writeWord(mesD04Address, 0);
			// }
			// if (!REQUEST_WORD.equals(d03ToMES)) {
			// log.info("地址：{}写入0", mesD03Address);
			// S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
			// }
			// if (!REQUEST_WORD.equals(d05ToMES)) {
			// log.info("地址：{}写入0", mesD05Address);
			// S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
			// }
			// }
			//
			// /**
			// * 进片状态修改
			// */
			//// @Scheduled(fixedDelay = 300)
			// public void feedStatusUpdate() {
			// PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
			// String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
			// String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
			// List<String> glassIds1 = new ArrayList<>();
			// List<String> glassIds2 = new ArrayList<>();
			// for (int i = 1; i <= 6; i++) {
			// String line1GlassId = plcParameterObject.getPlcParameter("D03ID" + i).getValue();
			// if (StringUtils.isNotEmpty(line1GlassId)) {
			// glassIds1.add(line1GlassId);
			// }
			// String line2GlassId = plcParameterObject.getPlcParameter("D05ID" + i).getValue();
			// if (StringUtils.isNotEmpty(line2GlassId)) {
			// glassIds2.add(line2GlassId);
			// }
			// }
			// List<BigStorageCageFeedTask> bigStorageCageFeedTasks1 = bigStorageCageFeedTaskService.list(
			// new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
			// .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
			// );
			// List<BigStorageCageFeedTask> bigStorageCageFeedTasks2 = bigStorageCageFeedTaskService.list(
			// new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
			// .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
			// );
			// if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks1) && CollectionUtils.isNotEmpty(glassIds1)) {
			// List<String> matchingIds1 = bigStorageCageFeedTasks1.stream()
			// .map(BigStorageCageFeedTask::getGlassId)
			// .filter(glassIds1::contains)
			// .distinct()
			// .collect(Collectors.toList());
			// log.info("D3id{},匹配id:{}", glassIds1, matchingIds1);
			// if (CollectionUtils.isNotEmpty(matchingIds1)) {
			// bigStorageCageFeedTaskService.update(
			// new LambdaUpdateWrapper<BigStorageCageFeedTask>()
			// .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
			// .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
			// .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
			// );
			// }
			// }
			// if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks2) && CollectionUtils.isNotEmpty(glassIds2)) {
			// List<String> matchingIds2 = bigStorageCageFeedTasks2.stream()
			// .map(BigStorageCageFeedTask::getGlassId)
			// .filter(glassIds2::contains)
			// .distinct()
			// .collect(Collectors.toList());
			// log.info("D5id{},匹配id:{}", glassIds2, matchingIds2);
			// if (CollectionUtils.isNotEmpty(matchingIds2)) {
			// bigStorageCageFeedTaskService.update(
			// new LambdaUpdateWrapper<BigStorageCageFeedTask>()
			// .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
			// .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
			// .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
			// );
			// }
			// }
			// if (CollectionUtils.isEmpty(glassIds1)) {
			// S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
			// log.info("{}线修改玻璃状态为3", Const.A09_OUT_TARGET_POSITION);
			// bigStorageCageFeedTaskService.update(
			// new LambdaUpdateWrapper<BigStorageCageFeedTask>()
			// .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
			// .gt(BigStorageCageFeedTask::getTargetSlot, 0)
			// .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
			// .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
			// );
			// }
			// if (CollectionUtils.isEmpty(glassIds2)) {
			// S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
			// log.info("{}线修改玻璃状态为3", Const.A10_OUT_TARGET_POSITION);
			// bigStorageCageFeedTaskService.update(
			// new LambdaUpdateWrapper<BigStorageCageFeedTask>()
			// .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
			// .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
			// .gt(BigStorageCageFeedTask::getTargetSlot, 0)
			// .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
			// .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
			// );
			// }
			// }
			//
			// /**
			// * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
			// */
			// public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
			// //判断此玻璃是在笼内或已生成进片任务
			// BigStorageCageFeedTask bigStorageCageFeedTask = bigStorageCageFeedTaskService.getOne(
			// new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
			// .eq(BigStorageCageFeedTask::getGlassId, glassId)
			// );
			// BigStorageCageDetails bigStorageCageDetails = bigStorageCageDetailsService.getOne(
			// new LambdaQueryWrapper<BigStorageCageDetails>()
			// .eq(BigStorageCageDetails::getGlassId, glassId)
			// .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
			// );
			// if (bigStorageCageFeedTask != null \|\| bigStorageCageDetails != null) {
			// log.info("此玻璃存任务或已在笼内");
			// return Boolean.TRUE;
			// }
			// //1、获取任务表中相邻玻璃
			// List<EdgGlassTaskInfo> edgGlassTaskInfoList;
			// edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
			// .eq(EdgGlassTaskInfo::getLine, line)
			// .apply("time >= (select time from edg_glass_task_info where line='" + line + "' and glass_id = '" + glassId + "' and deleted = 0)")
			// .orderByAsc(EdgGlassTaskInfo::getCreateTime));
			// if (edgGlassTaskInfoList.size() == 0) {
			// edgGlassTaskInfoList = edgGlassTaskInfoService.list(new QueryWrapper<EdgGlassTaskInfo>()
			// .select("Top 1 *")
			// .eq("glass_id", glassId)
			// );
			// log.info("在尺寸表中获取玻璃信息{}", edgGlassTaskInfoList);
			// if (edgGlassTaskInfoList.size() == 0) {
			// GlassInfo glassInfo = glassInfoService.getOne(
			// new LambdaQueryWrapper<GlassInfo>()
			// .eq(GlassInfo::getGlassId, glassId)
			// );
			// EdgGlassTaskInfo edgGlassTaskInfo = new EdgGlassTaskInfo();
			// BeanUtils.copyProperties(glassInfo, edgGlassTaskInfo);
			// edgGlassTaskInfo.setWidth((int) glassInfo.getWidth());
			// edgGlassTaskInfo.setHeight((int) glassInfo.getHeight());
			// edgGlassTaskInfoList.add(edgGlassTaskInfo);
			// log.info("在玻璃信息表中获取玻璃信息{}", edgGlassTaskInfoList);
			// }
			// }
			// Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");
			// //2、获取卧转立剩余宽度
			// BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
			// Integer remainWidth;
			// Integer glassCount;
			// if (0 == sitToUpRemainWidth.getGlassCount()) {
			// remainWidth = carWidth;
			// glassCount = 0;
			// } else {
			// remainWidth = sitToUpRemainWidth.getWidth();
			// glassCount = sitToUpRemainWidth.getGlassCount();
			// }
			//
			// Boolean flag = Boolean.TRUE;
			// //2、获取卧转立
			// Integer widthFirst = Math.max(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
			// Integer heightFirst = Math.min(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
			// if (edgGlassTaskInfoList.size() == 1) {
			// if (remainWidth >= widthFirst) {
			// if (glassCount < inCarMaxSize) {
			// addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);
			// } else {
			// if (glassCount < inCarMaxSize + 1) {
			// addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
			// } else {
			// return Boolean.FALSE;
			// }
			// }
			// } else {
			// flag = Boolean.FALSE;
			// }
			// } else {
			// Integer widthSecond = Math.max(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
			// Integer heightSecond = Math.min(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
			// if (remainWidth >= widthFirst) {
			// if (remainWidth - widthFirst - glassGap >= widthSecond) {
			// if (glassCount < inCarMaxSize) {
			// addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);
			// } else {
			// if (glassCount < inCarMaxSize + 1) {
			// addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
			// } else {
			// return Boolean.FALSE;
			// }
			// }
			// } else {
			// if (glassCount < inCarMaxSize + 1) {
			// addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
			// } else {
			// return Boolean.FALSE;
			// }
			// }
			// } else {
			// flag = Boolean.FALSE;
			// }
			// }
			// //向plc发送进片确认
			// if (flag) {
			// //向plc写入确认字
			// PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
			// int returnData = 1;
			// int count = 1;
			// while (returnData != 0) {
			// S7object.getinstance().plccontrol.writeWord(mesAddress, 1);
			//
			// if (Const.A10_OUT_TARGET_POSITION.equals(line)) {
			// returnData = Integer.parseInt(plcParameterObject.getPlcParameter("D04ToMES").getValue());
			// } else {
			// returnData = Integer.parseInt(plcParameterObject.getPlcParameter("D01ToMES").getValue());
			// }
			//// returnData = S7object.getinstance().plccontrol.readWord(mesAddress, 1).get(0);
			// log.info("进卧转立第{}次发送确认字完成，地址为：{},写入的内容为{}", count++, mesAddress, 1);
			// }
			// }
			// //记录无法放下玻璃，后续判断启动
			// return flag;
			// }
			//
			// /**
			// * 添加任务信息
			// */
			// private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width, Integer height) {
			// BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask();
			// bigStorageCageFeedTask.setGlassId(glassId);
			// bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_IN_NEW);
			// bigStorageCageFeedTask.setLine(line);
			// bigStorageCageFeedTask.setTaskType(taskType);
			// bigStorageCageFeedTask.setWidth(width);
			// bigStorageCageFeedTask.setHeight(height);
			// bigStorageCageFeedTask.setCreateTime(new Date());
			// //删除理片笼表拿走/破损数据数据
			// damageService.deleteByGlassId(glassId);
			// Damage damage = new Damage();
			// damage.setGlassId(glassId);
			// damage.setWorkingProcedure("磨边");
			// damage.setLine(line);
			// damage.setType(1);
			// damage.setRemark("进大理片");
			// damageService.insertDamage(damage);
			// 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" +
			// "and (target_slot = 0 or target_slot is null) 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) {
			// //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
			// List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
			// .eq(BigStorageCageFeedTask::getLine, line)
			// .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
			// .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP_ALL)
			// .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));
			// return computeIsTemperingTargetByLine(glassInfos, taskList, line);
			// }
			//
			// /**
			// * 是否钢化玻璃进笼目标位置
			// *
			// * @param glassInfos 当条线卧转立所有玻璃
			// * @param taskList 当条线卧转立所有任务
			// * @param line 任务是哪条线
			// */
			// private boolean computeIsTemperingTargetByLine(List<GlassInfo> glassInfos, List<BigStorageCageFeedTask> taskList, Integer line) {
			// //1、将玻璃信息集合转为glassid为key的map
			// Map<String, GlassInfo> glassInfoMap = glassInfos.stream()
			// .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
			// for (BigStorageCageFeedTask e : taskList) {
			// GlassInfo info = glassInfoMap.get(e.getGlassId());
			// if (info == null) {
			// continue;
			// }
			// BigStorageCageDetails cageDetails = new BigStorageCageDetails();
			// BeanUtils.copyProperties(info, cageDetails);
			// //2、获取目标格子信息
			// BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
			// //3、临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
			// bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
			// .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
			// //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理）遇到问题：无法批量更新，批量更新无法走指定从库
			// e.setTargetSlot(bigStorageDTO.getSlot());
			// bigStorageCageFeedTaskService.updateById(e);
			//
			// //5、将进片信息存入大理片笼详情表
			// cageDetails.setSlot(bigStorageDTO.getSlot());
			// cageDetails.setState(Const.GLASS_STATE_NEW);
			// cageDetails.setDeviceId(bigStorageDTO.getDeviceId());
			// cageDetails.setGap(glassGap);
			// bigStorageCageDetailsService.save(cageDetails);
			//
			// }
			// sendTaskListToPLC(taskList, line);
			// return Boolean.TRUE;
			// }
			//
			// private void sendTaskListToPLC(List<BigStorageCageFeedTask> taskList, Integer line) {
			// log.info("送片任务发送进片玻璃信息");
			// S7control s7control = S7object.getinstance().plccontrol;
			// PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
			// String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress();
			// String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getAddress();
			// String outLine = line.equals(Const.A09_OUT_TARGET_POSITION) ? mesD03Address : mesD05Address;
			// List<String> returnData = new ArrayList<>();
			//
			// for (int i = 1; i <= taskList.size(); i++) {
			// s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
			// s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
			// returnData.add(taskList.get(i - 1).getGlassId());
			// log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());
			// }
			//// int returnData = 1;
			// int count = 1;
			//
			//
			// while (CollectionUtils.isNotEmpty(returnData)) {
			// List<String> glassIds1 = new ArrayList<>();
			// List<String> glassIds2 = new ArrayList<>();
			// s7control.writeWord(outLine, 2);
			// for (int i = 1; i <= 6; i++) {
			// String line1GlassId = plcMesObject.getPlcParameter("D03ID" + i).getValue();
			// if (StringUtils.isNotEmpty(line1GlassId)) {
			// glassIds1.add(line1GlassId);
			// }
			// String line2GlassId = plcMesObject.getPlcParameter("D05ID" + i).getValue();
			// if (StringUtils.isNotEmpty(line2GlassId)) {
			// glassIds2.add(line2GlassId);
			// }
			// }
			// if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
			//// returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
			// returnData = glassIds1;
			// } else {
			//// returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
			// returnData = glassIds2;
			// }
			//// returnData = s7control.readWord(outLine, 1).get(0);
			// log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2, returnData);
			// }
			//// while (returnData != 0) {
			//// s7control.writeWord(outLine, 2);
			//// if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
			////// returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
			//// returnData = s7control.readWord(plcMesObject.getPlcParameter("D03Request").getAddress(), 1).get(0);
			//// } else {
			////// returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
			//// returnData = s7control.readWord(plcMesObject.getPlcParameter("D05Request").getAddress(), 1).get(0);
			//// }
			////// returnData = s7control.readWord(outLine, 1).get(0);
			//// log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2,returnData);
			//// }
			// }
			//
			// /**
			// * 出片一次仅生成一车玻璃
			// *
			// * @param list
			// * @param isTempering
			// * @param mesToPLCAddress
			// * @param <T>
			// * @return
			// */
			// private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
			// //任务数据获取车子存放玻璃最大数量玻璃间隔
			// List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
			// //打车剩余尺寸
			// Integer remainWidth = carWidth;
			// int maxX = 0;
			// for (T e : list) {
			// if (bigStorageCageOutTaskList.size() >= outCarMaxSize \|\| Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
			// break;
			// }
			// remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap;
			// if (isTempering) {
			// int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
			// if (maxX + minLength <= xMaxSize) {
			// bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
			// e.getWidth() * 10, e.getHeight() * 10, 0, 0, 1, new Date()));
			//// maxX = Math.max(maxX, e.getXCoordinate());
			// } else {
			// break;
			// }
			//
			// } else {
			// bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
			// e.getWidth() * 10, e.getHeight(), 0, 0, 1, new Date()));
			// }
			// }
			// Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
			// log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
			// bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
			// List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
			// log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
			// bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
			// .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
			// .in(BigStorageCageDetails::getGlassId, glassIds));
			// int returnData = 0;
			// int count = 1;
			// while (returnData == 0) {
			// S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
			// returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
			// log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
			// }
			// return Boolean.TRUE;
			// }
			//
			// /**
			// * 出片一次生成一炉玻璃
			// *
			// * @param list
			// * @param isTempering
			// * @param mesToPLCAddress
			// * @param <T>
			// * @return
			// */
			// public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
			// //任务数据获取车子存放玻璃最大数量玻璃间隔
			// List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
			// //打车剩余尺寸
			// Integer remainWidth = carWidth;
			// int trainNumber = 1;
			// int serialNumber = 1;
			// int maxX = 0;
			// for (T e : list) {
			// int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
			// if (serialNumber > outCarMaxSize \|\| maxLength > remainWidth) {
			// remainWidth = carWidth;
			// trainNumber = trainNumber + 1;
			// serialNumber = 1;
			// maxX = 0;
			// }
			// remainWidth = remainWidth - maxLength - glassGap;
			// if (isTempering) {
			// int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
			// if (maxX + minLength <= xMaxSize) {
			// bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
			// e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
			//// maxX = Math.max(maxX, e.getXCoordinate());
			// } else {
			// remainWidth = carWidth - maxLength - glassGap;
			// trainNumber = trainNumber + 1;
			// serialNumber = 1;
			//// maxX = e.getXCoordinate();
			// bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
			// e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
			// }
			// } else {
			// bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
			// e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
			// }
			// }
			// Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
			// log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
			// for (BigStorageCageOutTask bigStorageCageOutTask : bigStorageCageOutTaskList
			// ) {
			// bigStorageCageOutTaskService.save(bigStorageCageOutTask);
			// }
			//// bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
			// List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
			// log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
			// bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
			// .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
			// .in(BigStorageCageDetails::getGlassId, glassIds)
			// .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT));
			//// int returnData = 0;
			//// int count = 1;
			//// while (returnData == 0) {
			//// S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
			//// returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
			//// log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
			//// }
			// return Boolean.TRUE;
			// }
			//
			// public void updateSlotRemainBySlots(List<Integer> slotList) {
			// //获取格子内所有的玻璃信息
			// List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
			// .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
			// Map<Integer, Double> slotRemainMap = new HashMap<>();
			// //是否存在有格子非空的玻璃
			// if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
			// //存在将格子内的玻璃分别进行更新
			// slotRemainMap = inSlotGlassList.stream()
			// .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));
			// slotRemainMap.forEach((e, v) -> {
			// double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0;
			// bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, remainWidth)
			// .eq(BigStorageCage::getSlot, e));
			// });
			// }
			// //过滤不存在玻璃的格子将宽度重置为原始宽度5000
			// Set<Integer> remainSlotList = slotRemainMap.keySet();
			// slotList.removeAll(remainSlotList);
			// if (CollectionUtils.isNotEmpty(slotList)) {
			// bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
			// .in(BigStorageCage::getSlot, slotList));
			// }
			// }
			//
			// public Boolean computeIsRun(int line, String glassId) {
			// //获取卧转立剩余宽度
			// BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
			// if (sitToUpRemainWidth.getGlassCount() == 0) {
			// return Boolean.FALSE;
			// }
			// //获取玻璃信息
			// GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
			// return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight());
			// }
			//
			//}