YiWuProject.git

			@@ -3,6 +3,9 @@
			import cn.hutool.core.collection.CollectionUtil;
			import cn.hutool.core.lang.Assert;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.github.yulichang.query.MPJQueryWrapper;
			import com.github.yulichang.wrapper.MPJLambdaWrapper;
			import com.mes.common.S7object;
			import com.mes.common.config.Const;
			import com.mes.device.PlcParameterObject;
			@@ -21,6 +24,7 @@
			import org.springframework.scheduling.annotation.Scheduled;
			import org.springframework.stereotype.Component;

			import java.util.ArrayList;
			import java.util.Date;
			import java.util.List;

			@@ -51,12 +55,13 @@
			String taskRequestTypeValue = plcParameterObject.getPlcParameter("A06_request_word").getValue();
			String glassIdeValue = plcParameterObject.getPlcParameter("A05_scanning_ID").getValue();
			String confirmationWrodValue = plcParameterObject.getPlcParameter("MES_confirmation_word").getValue();
			// 1为A09空闲，2为A10空闲，3为A09A10都空闲,0为A09A10都有玻璃
			String outGlassstate = plcParameterObject.getPlcParameter("A09_glass_status").getValue();
			//A08 A09表示线路相同可做等价
			String out08Glassstate = plcParameterObject.getPlcParameter("A08_glass_status").getValue();
			String out10Glassstate = plcParameterObject.getPlcParameter("A10_glass_status").getValue();
			String confirmationWrodAddress = plcParameterObject.getPlcParameter("MES_confirmation_word").getAddress();
			String currentSlot = plcParameterObject.getPlcParameter("Current_slot").getValue();
			log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态为：{},当前格子号为：{}",
			taskRequestTypeValue, glassIdeValue, confirmationWrodValue, outGlassstate, currentSlot);
			log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态分别为：A09{}、A10{},当前格子号为：{}",
			taskRequestTypeValue, glassIdeValue, confirmationWrodValue, out08Glassstate, out10Glassstate, currentSlot);

			if ("0".equals(taskRequestTypeValue)) {
			if ("0".equals(confirmationWrodValue)) {
			@@ -79,19 +84,22 @@
			} else if ("2".equals(taskRequestTypeValue)) {
			//09空闲：1 10空闲：2 都空闲：3 其他0
			log.info("3、出片请求，且确认字为0，执行进片任务");
			outTo(Integer.parseInt(outGlassstate), confirmationWrodAddress, currentSlot);
			outTo(Integer.parseInt(out08Glassstate), confirmationWrodAddress);
			} else if ("3".equals(taskRequestTypeValue)) {
			log.info("3、进片和出片都空闲，执行出片任务");
			if ("0".equals(outGlassstate)) {
			//加笼子里面是否有玻璃，有先出，无玻璃先进
			int count = edgStorageCageDetailsService.count(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
			if ("0".equals(out08Glassstate) \|\| count > 0) {
			inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
			} else {
			outTo(Integer.parseInt(outGlassstate), confirmationWrodAddress, currentSlot);
			outTo(Integer.parseInt(out08Glassstate), confirmationWrodAddress);
			}
			}
			}

			/**
			* 进片任务
			*
			* @param glassId
			* @param confirmationWrodAddress
			* @param currentSlot
			@@ -137,31 +145,58 @@

			/**
			* 出片任务
			*
			* @param line
			* @param confirmationWrodAddress
			* @param currentSlot
			*/
			private void outTo(int line, String confirmationWrodAddress, String currentSlot) {
			private void outTo(int line, String confirmationWrodAddress) {
			//逻辑步骤：
			// 0、A09、A10是否空闲，是否可以执行出片任务
			// 1、获取钢化版图是否超过阈值
			// 1.1、超过阈值：获取当前最小版图需要出片的玻璃信息
			// 1.1.1、获取两条线最后一次出片的任务信息
			// 1.1.2、按照出片信息去详情表查询格子在笼子里面剩余相同尺寸的玻璃数据
			// 1.1.3、判断哪条线玻璃数量在理片笼内的数据最少，决定最小版图走该条线（问题：如果这条线非空闲，直接结束）
			// 1.2、未超过阈值：
			// 1.2.1、获取程序那条线空闲
			// 1.2.2、获取该条线最后一次出片的任务信息
			// 1.2.3、按照出片信息去详情表查询格子在笼子里面剩余相同尺寸的玻璃数据且以版图id、版序升序排序取第一块玻璃出片
			// 2、如果没有历史出片任务
			// 2.1、出当前版图id最小版序最小的玻璃（问题：两条线都没有历史任务，出片时两条线的玻璃尺寸相同，是否找尺寸不同的）
			Assert.isTrue(line != 0, "A09、A10都有玻璃，无法出片");
			log.info("1、出片任务出【{}】号线,备注(09空闲：1;10空闲：2;都空闲：3)", line);
			log.info("0、出片任务出【{}】号线,备注(09空闲：1;10空闲：2;都空闲：3)", line);
			//定义出片玻璃信息
			EdgStorageCageDetails glassInfo = null;
			int endcell = 0;

			List<TaskCache> oldTaskCacheList;
			if (line == 2) {
			endcell = Const.A10_OUT_TARGET_POSITION;
			oldTaskCacheList = taskCacheService.selectLastOutCacheInfos(Const.A10_OUT_TARGET_POSITION);
			} else {
			boolean flag = queryMaxMinDiff(threshold);
			log.info("1、获取钢化版图是否超过阈值:{}", flag);
			if (flag) {
			glassInfo = queryMinGlass(0.0, 0.0);
			log.info("1.1、超过阈值：获取当前最小版图需要出片的玻璃信息:{}", glassInfo);
			Integer a09Count = queryCountByTaskLine(Const.A09_OUT_TARGET_POSITION).size();
			Integer a10Count = queryCountByTaskLine(Const.A10_OUT_TARGET_POSITION).size();
			log.info("1.2、获取笼子剩余数量A09为{},A10为{}", a09Count, a10Count);
			if (a10Count <= a09Count && line != 2) {
			log.info("1.2.1、A09线出片");
			endcell = Const.A09_OUT_TARGET_POSITION;
			oldTaskCacheList = taskCacheService.selectLastOutCacheInfos(Const.A09_OUT_TARGET_POSITION);
			} else {
			log.info("1.2.2、A10线出片");
			endcell = Const.A09_OUT_TARGET_POSITION;
			}
			log.info("2、判断出片线路{}，获取最后该条线已出片的任务信息{}(备注：0待执行，1已执行).都空闲优先出A09线", endcell, oldTaskCacheList);
			} else {
			//获取指定线路将要出的玻璃信息
			endcell = line == 2 ? Const.A10_OUT_TARGET_POSITION : Const.A09_OUT_TARGET_POSITION;
			//当前任务出完无玻璃更换玻璃
			int othercell = endcell == Const.A10_OUT_TARGET_POSITION ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
			List<EdgStorageCageDetails> details = queryCountByTaskLine(endcell);
			if (details.size() > 0) {
			glassInfo = details.get(0);
			} else {
			//todo:去理片笼里面查
			glassInfo = queryChangeGlassInfo(othercell);
			}

			String glassId = "";
			if (CollectionUtil.isNotEmpty(oldTaskCacheList)) {
			glassId = oldTaskCacheList.get(0).getGlassId();
			}
			EdgStorageCageDetails glassInfo = edgStorageCageDetailsService.selectOutGlass(glassId, threshold);
			log.info("3、按照历史已出玻璃id{}和阈值{}，拿出理片笼内的出片信息{}", glassId, threshold, glassInfo);

			if (glassInfo != null) {
			log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
			@@ -176,9 +211,121 @@
			taskCacheService.insertTaskCache(taskCache);
			S7object.getinstance().plccontrol.WriteWord(confirmationWrodAddress, (short) 1);
			}


			}

			/**
			* 获取详情表内最大最小版图id的差值，判断是否出最小版图玻璃
			*
			* @return
			*/
			private boolean queryMaxMinDiff(int threshold) {
			//todo:获取笼子内最大版图id和最小版图id插值，判断是否大于阈值，大于阈值直接出最小版图玻璃
			QueryWrapper<EdgStorageCageDetails> queryWrapper = new QueryWrapper<>();
			queryWrapper.select("max(tempering_layout_id)-min(tempering_layout_id) as diff")
			.eq("state", Const.GLASS_STATE_IN);
			Integer diff = (Integer) edgStorageCageDetailsService.listObjs(queryWrapper).get(0);
			return diff > threshold;
			}

			/**
			* 获取当前最小版图需要出片的玻璃信息
			*
			* @param width
			* @param height
			*/
			private EdgStorageCageDetails queryMinGlass(Double width, Double height) {
			return edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
			.eq(EdgStorageCageDetails::getState, 100)
			.eq(width != 0, EdgStorageCageDetails::getWidth, width)
			.eq(height != 0, EdgStorageCageDetails::getHeight, height)
			.orderByAsc(EdgStorageCageDetails::getTemperingLayoutId, EdgStorageCageDetails::getTemperingFeedSequence)
			.last("limit 1"));
			}

			/**
			* 获取任务表中指定线路笼子内还剩余的玻璃数量
			*/
			private List<EdgStorageCageDetails> queryCountByTaskLine(int line) {
			//获取任务表中最后一次出片的玻璃id
			LambdaQueryWrapper<TaskCache> queryWrapper = new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT)
			.eq(TaskCache::getEndCell, line).orderByDesc(TaskCache::getCreateTime);
			List<TaskCache> taskCacheList = taskCacheService.list(queryWrapper);
			if (CollectionUtil.isEmpty(taskCacheList)) {
			return new ArrayList<>();
			}
			TaskCache taskCache = taskCacheList.get(0);
			MPJQueryWrapper<EdgStorageCageDetails> mpjLambdaWrapper = new MPJQueryWrapper<>();
			mpjLambdaWrapper.select("a.*")
			.innerJoin("edg_storage_cage_details t1 on t.width = t1.width and t.height = t1.height")
			.eq("t.glass_id", taskCache.getGlassId())
			.ne("t1.glass_id", taskCache.getGlassId())
			.orderByAsc("t1.tempering_layout_id", "t1.tempering_feed_sequence");
			List<EdgStorageCageDetails> details = edgStorageCageDetailsService.selectJoinList(EdgStorageCageDetails.class, mpjLambdaWrapper);
			if (CollectionUtil.isEmpty(details)) {
			return new ArrayList<>();
			}
			return details;
			}

			/**
			* 更换出片玻璃
			*
			* @param othercell
			* @return
			*/
			private EdgStorageCageDetails queryChangeGlassInfo(int othercell) {
			//获取笼子内数量前二的玻璃数量
			MPJLambdaWrapper<EdgStorageCageDetails> wrapper = new MPJLambdaWrapper<>();
			wrapper.select(EdgStorageCageDetails::getWidth, EdgStorageCageDetails::getHeight)
			.selectCount("*", EdgStorageCageDetails::getCount)
			.groupBy(EdgStorageCageDetails::getWidth, EdgStorageCageDetails::getHeight)
			.last("order by count(*) desc limit 2");
			List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(wrapper);
			log.info("获取笼子内数量前二的玻璃数量：{}", list);
			Assert.notEmpty(list, "笼子里没有玻璃");
			//一片玻璃直接出
			if (list.size() == 1) {
			return list.get(0);
			}
			//分别获取宽高的玻璃数量
			EdgStorageCageDetails firstSize = list.get(0);
			EdgStorageCageDetails secondSize = list.get(1);
			//获取任务表中最后一次出片的玻璃id
			LambdaQueryWrapper<TaskCache> queryWrapper = new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT)
			.eq(TaskCache::getEndCell, othercell).orderByDesc(TaskCache::getCreateTime);
			List<TaskCache> taskCacheList = taskCacheService.list(queryWrapper);
			log.info("获取任务表中{}线最后一次出片的玻璃任务信息：{}", othercell, taskCacheList);
			if (CollectionUtil.isEmpty(taskCacheList)) {
			log.info("{}线没有出片任务信息，直接出片", othercell);
			return queryMinGlass(firstSize.getWidth(), firstSize.getHeight());
			}
			Integer firstCount = firstSize.getCount();
			Double firstWidth = firstSize.getWidth();
			Double firstHeight = firstSize.getHeight();
			Integer secondCount = secondSize.getCount();
			Double secondWidth = secondSize.getWidth();
			Double secondHeight = secondSize.getHeight();
			//获取数量前2的玻璃数量比例
			Integer mix = firstCount / secondCount;
			log.info("获取玻璃数量前2的玻璃占比为：{}", mix);

			if (mix >= 2) {
			log.info("获取玻璃数量前2的玻璃占比为{}，大于2，直接出玻璃数据的最多的，宽：{}，高：{}", mix, firstWidth, firstHeight);
			return queryMinGlass(firstWidth, firstHeight);
			} else {
			log.info("获取玻璃数量前2的玻璃占比为{}，小于2", mix);
			TaskCache taskCache = taskCacheList.get(0);
			EdgStorageCageDetails outGlassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getGlassId, taskCache.getGlassId()));
			log.info("{}线有出片任务信息,任务信息为{}，玻璃信息为{}", othercell, taskCache, outGlassInfo);
			if (outGlassInfo.getWidth().equals(firstWidth) && outGlassInfo.getHeight().equals(firstHeight)) {
			log.info("数量最多的宽{}高{}和{}线任务的宽{}高{}相同，出数量排第二的玻璃，宽{}高{}",
			firstWidth, firstHeight, othercell, outGlassInfo.getWidth(), outGlassInfo.getHeight(), secondWidth, secondHeight);
			return queryMinGlass(secondWidth, secondHeight);
			} else {
			log.info("数量第二多的宽{}高{}和{}线任务的宽{}高{}相同，出数量排第二的玻璃，宽{}高{}",
			secondWidth, secondHeight, othercell, outGlassInfo.getWidth(), outGlassInfo.getHeight(), firstWidth, firstHeight);
			return queryMinGlass(firstWidth, firstHeight);
			}
			}
			}
			}