zy-wcs.git - Gitblit

			@@ -3,6 +3,7 @@
			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			import com.baomidou.mybatisplus.mapper.Wrapper;
			import com.core.common.Cools;
			import com.core.exception.CoolException;
			import com.zy.asrs.entity.*;
			@@ -114,33 +115,33 @@
			}
			Short workNo = staProtocol.getWorkNo();

			//20230201. 2号堆垛机有出库任务时，禁止新板入库
			if (staProtocol.isLoading() && staProtocol.getWorkNo() == 9995) {
			if ( inSta.getStaNo()==103 && devpThread.ioModeOf1F == IoModeType.PAKOUT_MODE) {
			//有出库任务，退库到入库口
			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo((short)100);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			News.error("MainServiceImpl generateStoreWrkFile"+"103为出库模式，禁止入库，退回入库口。！！！");
			continue;
			}
			if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
			//有出库任务，退库到入库口
			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo((short)200);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			News.error("MainServiceImpl generateStoreWrkFile"+"203为出库模式，禁止入库，退回入库口。！！！");
			continue;
			}
			}

			// 判断是否满足入库条件
			if (staProtocol.isAutoing() && staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && (workNo == 0 \|\| (workNo >= 9990 && workNo <= 9999))
			&& staProtocol.isPakMk()) {

			//20230201. 2号堆垛机有出库任务时，禁止新板入库
			if (staProtocol.getWorkNo() == 9995) {
			if ( inSta.getStaNo()==103 && devpThread.ioModeOf1F == IoModeType.PAKOUT_MODE) {
			//有出库任务，退库到入库口
			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo((short)100);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			News.error("MainServiceImpl generateStoreWrkFile"+"103为出库模式，禁止入库，退回入库口。！！！");
			continue;
			}
			if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
			//有出库任务，退库到入库口
			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo((short)200);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			News.error("MainServiceImpl generateStoreWrkFile"+"203为出库模式，禁止入库，退回入库口。！！！");
			continue;
			}
			}

			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			@@ -240,6 +241,22 @@
			String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			} else if (code == 1000){
			if (inSta.getStaNo().equals(103)){
			staProtocol.setWorkNo((short)9996);
			staProtocol.setStaNo((short)203);
			}else {
			staProtocol.setWorkNo((short)9996);
			staProtocol.setStaNo((short)103);
			}
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

			// led 异常显示
			if (ledThread != null) {
			String errorMsg = barcode + "需要换入库站。目标站："+staProtocol.getStaNo();
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			}
			} catch (Exception e) {
			e.printStackTrace();
			@@ -326,15 +343,18 @@
			continue;
			}
			short staNo;
			List<BasDevp> basDevps1 = basDevpMapper.getLoading(103);
			List<BasDevp> basDevps2 = basDevpMapper.getLoading(203);

			switch (wrkMast.getSourceStaNo()) {
			case 104:
			case 108:
			staNo = 103;
			List<BasDevp> basDevps1 = basDevpMapper.getLoading(103);
			if (basDevps1.size()!=0){
			if (basDevps1.size()!=0 && basDevps2.size()!=0){
			continue;
			}
			List<WrkMast> wrkMasts1 = wrkMastMapper.selectWrkStsAndIoType(103);

			List<WrkMast> wrkMasts1 = wrkMastMapper.selectWrkStsAndIoType((int)staNo);
			if (wrkMasts1.size()!=0){
			boolean flag = false;
			for (WrkMast wrkMast1:wrkMasts1){
			@@ -352,11 +372,14 @@
			case 204:
			case 208:
			staNo = 203;
			List<BasDevp> basDevps2 = basDevpMapper.getLoading(203);
			if (basDevps2.size()!=0){
			if (basDevps1.size()!=0 && basDevps2.size()!=0){
			continue;
			}
			List<WrkMast> wrkMasts2 = wrkMastMapper.selectWrkStsAndIoType(203);

			// if (basDevps2.size()!=0){
			// continue;
			// }
			List<WrkMast> wrkMasts2 = wrkMastMapper.selectWrkStsAndIoType((int)staNo);
			if (wrkMasts2.size()!=0){
			boolean flag = false;
			for (WrkMast wrkMast1:wrkMasts2){
			@@ -380,9 +403,17 @@
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(staNo);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			if (staProtocol.getStaNo().equals(300)){
			BasDevp basDevp = basDevpMapper.selectByDevNo(300);
			basDevp.setWrkNo1(wrkMast.getWrkNo());
			basDevpService.selectById(basDevp);
			News.info("300站去入库站任务下发，更新站点表，[任务号:{}，站点号:{}]", wrkMast.getWrkNo().shortValue(), staNo);
			}
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			} else {
			News.info("300站去入库站任务已下发，[任务号:{}，站点号:{}]", wrkMast.getWrkNo().shortValue(), staNo);
			}
			}
			}
			@@ -474,132 +505,231 @@
			continue;
			}

			try {
			// 访问 WMS 获取入库库位
			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			SearchLocParam param = new SearchLocParam();
			param.setWrkNo(wrkMast.getWrkNo());
			param.setIoType(wrkMast.getIoType());
			param.setSourceStaNo(pickSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			.setJson(JSON.toJSONString(param))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			// 获取目标站
			Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
			.eq("type_no", wrkMast.getIoType() - 50)
			.eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
			.eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
			StaDesc staDesc = staDescService.selectOne(wrapper);
			if (Cools.isEmpty(staDesc)) {
			// led 异常显示
			String errorMsg = "";
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			Integer code = jsonObject.getInteger("code");
			if (code.equals(200)) {
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			// // 获取目标站
			// Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
			// .eq("type_no", wrkMast.getIoType() - 50)
			// .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
			// .eq("crn_no", dto.getCrnNo()); // 堆垛机号
			// StaDesc staDesc = staDescService.selectOne(wrapper);
			// if (Cools.isEmpty(staDesc)) {
			// News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			// continue;
			// }
			// // 堆垛机站点(目标站)
			// Integer staNo = staDesc.getCrnStn();

			// 保存工作明细档历史档
			// if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
			// throw new CoolException("保存工作明细档历史档失败");
			// }
			// 保存工作主档历史档
			if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
			}

			String sourceLocNo = wrkMast.getSourceLocNo().trim();

			// 更新工作档数据状态
			wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
			wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
			wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
			wrkMast.setStaNo(dto.getStaNo()); // 目标站
			wrkMast.setCrnNo(dto.getCrnNo());
			wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
			wrkMast.setSourceLocNo(""); // 源库位清空
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}
			if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}

			LocMast locMast = null;
			// 修改目标库位状态 Q.拣料/盘点/并板再入库
			locMast = locMastService.selectById(wrkMast.getLocNo());
			locMast.setLocSts("Q");
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
			}
			// 源库位库存明细转移到目标库位
			if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
			throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
			}

			// 修改源库位状态 O.空库位
			LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
			if (sourceLocMast.getLocSts().equals("P")) {
			sourceLocMast.setLocSts("O");
			sourceLocMast.setBarcode("");
			sourceLocMast.setModiTime(new Date());
			if (!locMastService.updateById(sourceLocMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			}
			locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
			}

			// 条码设备处理
			barcodeThread.setBarcode("");

			ledThread.errorReset();

			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}

			} else if (code == 500){
			if (ledThread != null) {
			String errorMsg = jsonObject.getString("msg");
			if (!Cools.isEmpty(errorMsg)) {
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			}
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			if (wrkMast.getIoType() == 103) {
			errorMsg = "当前拣料任务请移动至203站";
			} else {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

			// led 异常显示
			if (ledThread != null) {
			String errorMsg = jsonObject.getString("msg");
			// String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			errorMsg = "当前拣料任务请移动至103站";
			}

			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// continue;
			if (ledThread != null) {MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));}
			News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			continue;
			}
			// 堆垛机站点(目标站)
			Integer staNo = staDesc.getCrnStn();

			// 保存工作明细档历史档
			if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
			throw new CoolException("保存工作明细档历史档失败");
			}
			// 保存工作主档历史档
			if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
			}

			String sourceLocNo = wrkMast.getSourceLocNo().trim();

			// 更新工作档数据状态
			wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
			wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
			wrkMast.setIoPri(13D);
			wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
			wrkMast.setStaNo(staNo); // 目标站
			wrkMast.setCrnNo(wrkMast.getCrnNo());
			wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
			wrkMast.setSourceLocNo(""); // 源库位清空
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}
			if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}

			LocMast locMast = null;
			// 修改目标库位状态 Q.拣料/盘点/并板再入库
			locMast = locMastService.selectById(wrkMast.getLocNo());
			locMast.setLocSts("Q");
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
			}
			// 源库位库存明细转移到目标库位
			if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
			throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
			}

			// 修改源库位状态 O.空库位
			LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
			if (sourceLocMast.getLocSts().equals("P")) {
			sourceLocMast.setLocSts("O");
			sourceLocMast.setBarcode("");
			sourceLocMast.setModiTime(new Date());
			if (!locMastService.updateById(sourceLocMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			}
			locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
			}

			// 条码设备处理
			barcodeThread.setBarcode("");

			if(wrkMast.getIoType()>100){
			throw new CoolException("再入库更新工作档失败，不能给PLC下发任务===>>" + wrkMast.getWrkNo());
			}
			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			if (staProtocol.getStaNo().equals(300)){
			BasDevp basDevp = basDevpMapper.selectByDevNo(300);
			basDevp.setWrkNo1(wrkMast.getWrkNo());
			basDevpService.selectById(basDevp);
			}
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}

			// try {
			// // 访问 WMS 获取入库库位
			// LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			// SearchLocParam param = new SearchLocParam();
			// param.setWrkNo(wrkMast.getWrkNo());
			// param.setIoType(wrkMast.getIoType());
			// param.setSourceStaNo(pickSta.getStaNo());
			// param.setLocType1(locTypeDto.getLocType1());
			// String response = new HttpHandler.Builder()
			// .setUri(wmsUrl)
			// .setPath("/rpc/pakin/loc/v1")
			// .setJson(JSON.toJSONString(param))
			// .build()
			// .doPost();
			// JSONObject jsonObject = JSON.parseObject(response);
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			// Integer code = jsonObject.getInteger("code");
			// if (code.equals(200)) {
			// StartupDto dto = jsonObject.getObject("data", StartupDto.class);
			// News.info("再入库获取新库位成功，返回数据===>>", JSON.toJSON(dto));
			//// // 获取目标站
			//// Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
			//// .eq("type_no", wrkMast.getIoType() - 50)
			//// .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
			//// .eq("crn_no", dto.getCrnNo()); // 堆垛机号
			//// StaDesc staDesc = staDescService.selectOne(wrapper);
			//// if (Cools.isEmpty(staDesc)) {
			//// News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			//// continue;
			//// }
			//// // 堆垛机站点(目标站)
			//// Integer staNo = staDesc.getCrnStn();
			//
			// // 保存工作明细档历史档
			//// if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
			//// throw new CoolException("保存工作明细档历史档失败");
			//// }
			// // 保存工作主档历史档
			// if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
			// throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
			// }
			//
			// String sourceLocNo = wrkMast.getSourceLocNo().trim();
			//
			// // 更新工作档数据状态
			// wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
			// wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
			// wrkMast.setIoPri(13D);
			// wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
			// wrkMast.setStaNo(dto.getStaNo()); // 目标站
			// wrkMast.setCrnNo(dto.getCrnNo());
			// wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
			// wrkMast.setSourceLocNo(""); // 源库位清空
			// wrkMast.setModiTime(new Date());
			// if (wrkMastMapper.updateById(wrkMast) == 0) {
			// throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			// }
			// if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			// throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			// }
			//
			// LocMast locMast = null;
			// // 修改目标库位状态 Q.拣料/盘点/并板再入库
			// locMast = locMastService.selectById(wrkMast.getLocNo());
			// locMast.setLocSts("Q");
			// locMast.setModiTime(new Date());
			// if (!locMastService.updateById(locMast)) {
			// throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
			// }
			// // 源库位库存明细转移到目标库位
			// if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
			// throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
			// }
			//
			// // 修改源库位状态 O.空库位
			// LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
			// if (sourceLocMast.getLocSts().equals("P")) {
			// sourceLocMast.setLocSts("O");
			// sourceLocMast.setBarcode("");
			// sourceLocMast.setModiTime(new Date());
			// if (!locMastService.updateById(sourceLocMast)) {
			// throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			// }
			// locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
			// }
			//
			// // 条码设备处理
			// barcodeThread.setBarcode("");
			//
			// ledThread.errorReset();
			//
			// if(wrkMast.getIoType()>100){
			// throw new CoolException("再入库更新工作档失败，不能给PLC下发任务===>>" + wrkMast.getWrkNo());
			// }
			// // 更新站点信息且下发plc命令
			// staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			// staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// if (!result) {
			// News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			// }
			//
			// } else if (code == 500){
			// if (ledThread != null) {
			// String errorMsg = jsonObject.getString("msg");
			// if (!Cools.isEmpty(errorMsg)) {
			// MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			// }
			// }
			// News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			// } else {
			// staProtocol.setWorkNo((short) 9995);
			// staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			//
			// // led 异常显示
			// if (ledThread != null) {
			// String errorMsg = jsonObject.getString("msg");
			//// String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			// MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			// }
			// }
			//
			// } catch (Exception e) {
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			//// continue;
			// }

			}
			}
			@@ -744,6 +874,7 @@
			// 更新工作档状态为 17.出库完成
			wrkMast.setWrkSts(17L);
			wrkMast.setSteNo(0);
			wrkMast.setIoPri(15D);
			wrkMast.setCrnEndTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) != 0) {
			// 复位堆垛机
			@@ -805,6 +936,8 @@
			}
			// 库位移转
			this.locToLoc1(crn, crnProtocol);
			// 库位移转(高频移库，io_type=111)
			this.locToLoc111(crn, crnProtocol);
			// 库位移转，回原库位
			this.locToLoc17(crn, crnProtocol);
			// 演示任务
			@@ -841,11 +974,87 @@
			continue;
			}

			// 入库深库位是否有非F、D、X库位进行校验（ Q、P、R、S）
			if (wrkMastMapper.selectShallowLoc(Integer.parseInt(wrkMast.getLocNo().substring(0, 2)),Integer.parseInt(wrkMast.getLocNo().substring(2, 5)),Integer.parseInt(wrkMast.getLocNo().substring(5, 7)))!=null){
			//检查入库库位是否是在堆垛机边库位
			ArrayList<Integer> outLoc = new ArrayList<>();
			outLoc.add(3);outLoc.add(4);outLoc.add(11);outLoc.add(12);outLoc.add(18);outLoc.add(19);
			if (!outLoc.contains(Integer.parseInt(wrkMast.getLocNo().substring(0, 2)))) {
			continue;
			}
			}


			//加强判断，只要存在移库任务，说明出库任务未完全结束，不执行入库任务
			WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
			if(!Cools.isEmpty(one)){
			News.error("入库 ===>> 存在移库未完成任务，不能入库。移库任务号={},堆垛机号={}", one.getWrkNo(), slave.getId());
			// continue;
			}

			//入库库位不是最外层库位，判断最外层库位是否为空库位，如不是则进行移库任务
			if(!locMastService.isOutMost(wrkMast.getLocNo())) {
			WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
			if (wrkMastMove != null && wrkMast.getWrkNo() == 111) {
			continue;
			}

			WrkMast two = wrkMastMapper.selectWorking1(slave.getId(), wrkMast.getWrkNo());
			if (two != null) {//2号机有在执行任务时，禁止生成移库工作档
			continue;
			} else {
			List<String> shallowLocs = Utils.getShallowLocs(wrkMast.getLocNo());
			if (!Cools.isEmpty(shallowLocs)) {
			for (String shallowLocNo : shallowLocs) {
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			if (null == waitWrkMast) {
			// 生成一笔移库任务工作档、改变浅库位的源库/目标库库位状态
			// 没有作业中的入库任务时，才能生成移库任务
			WrkMast one2 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("crn_no", slave.getId())
			.last(" and wrk_sts in (3,4,5,6,7,8)"));
			if (one2 == null) {
			moveLocForDeepLoc(slave, shallowLoc);
			// 置顶任务
			wrkMast.setIoPri((double) 9999);
			wrkMastMapper.updateById(wrkMast);
			} else {
			News.error("浅库位阻塞时，且浅库位存在作业中出库任务！工作号={}", one2.getWrkNo());
			}
			flag = true;
			break;
			} else {
			if (waitWrkMast.getWrkSts() != 18) {
			News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}

			}
			// } else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")) {
			// News.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			// flag = true;
			// break;
			} else if (shallowLoc.getLocSts().equals("R") \|\| shallowLoc.getLocSts().equals("P")) {
			News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}

			// //20230307 ADD，再加一次判断，当浅库位状态不为O时，不执行当前出库任务
			// if (shallowLoc != null && !shallowLoc.getLocSts().equals("O")) {
			// News.error("做了浅库位阻塞处理后反复判断，浅库位状态不为O ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", wrkMast.getSourceLocNo(), shallowLoc.getLocNo());
			// flag = true;
			// break;
			// }
			}
			}
			}
			}
			if(flag){
			return false;
			}

			// 判断是否已存在小车绑定任务
			@@ -1029,6 +1238,10 @@
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 3L) {
			if (Cools.isEmpty(wrkMast.getSteNo()) \|\| wrkMast.getSteNo()==0){
			News.error("工作号={}即将开始搬运小车但是工作档没有小车号",wrkMast.getWrkNo());
			return false;
			}
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			}
			}
			@@ -1042,6 +1255,7 @@
			* 出库 ===>> 库位到堆垛机站
			*/
			public synchronized boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
			Collections.shuffle(slave.getCrnOutStn());
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			// 获取工作状态为11（生成出库ID）的出库工作档
			WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
			@@ -1061,11 +1275,11 @@
			if (wrkMast.getCrnNo().equals(2)){
			if (wrkMast.getStaNo() == 103 && devpThread.ioModeOf1F != IoModeType.PAKOUT_MODE) {
			News.error("MainServiceImpl locToCrnStn"+"103非出库模式，禁止出库。任务号:{}！！！",wrkMast.getWrkNo());
			continue;
			return false;
			}
			if (wrkMast.getStaNo() == 203 && devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) {
			News.error("MainServiceImpl locToCrnStn"+"203非出库模式，禁止出库。任务号:{}！！！",wrkMast.getWrkNo());
			continue;
			return false;
			}

			if (wrkMast.getWrkSts() == 11 && (wrkMast.getIoType() == 103 \|\| wrkMast.getIoType() == 107)){
			@@ -1073,6 +1287,15 @@
			List<WrkMast> wrkMasts = wrkMastMapper.selectWrkStsAndIoType0(sour);
			if (wrkMasts.size() > 0){
			News.error("MainServiceImpl 1028行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
			return false;
			}

			//如果存在目标站300且正在执行的拣料/盘点任务，则2号堆垛机不允许做拣料/盘点出库
			WrkMast one = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("sta_no",300)
			.last(" and wrk_sts>11 and io_type in (103,107) "));
			if(!Cools.isEmpty(one)){
			News.error("MainServiceImpl 1099行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
			continue;
			}
			}
			@@ -1081,8 +1304,12 @@
			Integer sour = wrkMast.getSourceStaNo();
			List<WrkMast> wrkMasts = wrkMastMapper.selectWrkStsAndIoType1(sour);
			if (wrkMasts.size() > 0){
			News.error("MainServiceImpl 1028行"+"204存在全板出库中货物，2号堆垛机暂时禁止全板出库！！！");
			continue;
			for (WrkMast one : wrkMasts){
			if(one.getWrkNo().equals(wrkMast.getWrkNo())){
			News.error("MainServiceImpl 1028行"+"204存在全板出库中货物，2号堆垛机暂时禁止全板出库！！！");
			return false;
			}
			}
			}
			}
			}
			@@ -1095,7 +1322,7 @@
			.last(" and wrk_sts < 10"));
			if(one1 != null){
			News.error("{}出库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
			continue;
			return false;
			}

			//加强判断，确保因出库导致的移库整套任务全部结束后，才能执行下一笔出库任务。只有库位完成移库回去全部任务后，才认为当组出库任务完成
			@@ -1115,67 +1342,93 @@
			}
			}

			//出库库位不是最外层库位，判断浅库位组是否都为空，或存在库位移转任务
			//出库库位不是最外层库位，判断最外层库位是否为空库位，如不是则进行移库任务
			boolean flag = false;
			if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
			if(!locMastService.isOutMost(wrkMast.getSourceLocNo())) {
			WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
			if(wrkMastMove != null && wrkMast.getWrkNo() == 11){
			if (wrkMastMove != null && wrkMast.getWrkNo() == 111) {
			continue;
			}

			String[] shallowlocs = Utils.getShallowLocs(wrkMast.getSourceLocNo());
			if(!Cools.isEmpty(shallowlocs)){
			for(String shallowLocNo : shallowlocs){
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			if (null == waitWrkMast) {
			News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			//iotype=11，wrksts=17，说明货物已经移库到暂存库位，等待回原库位,此时允许继续出库
			if (waitWrkMast.getIoType()!=11 \|\| waitWrkMast.getWrkSts()!=17) {
			waitWrkMast.setIoPri((double) 9999);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			WrkMast two = wrkMastMapper.selectWorking1(slave.getId(), wrkMast.getWrkNo());
			if (two != null) {//2号机有在执行任务时，禁止生成移库工作档
			continue;
			} else {
			List<String> shallowLocs = Utils.getShallowLocs(wrkMast.getSourceLocNo());
			if (!Cools.isEmpty(shallowLocs)) {
			for (String shallowLocNo : shallowLocs) {
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			if (Cools.isEmpty(waitWrkMast)){
			News.error("库位异常");
			}else {
			if (waitWrkMast.getIoType() != 11 \|\| waitWrkMast.getWrkSts() != 17){
			if(waitWrkMast.getIoPri()<=9980.0){
			waitWrkMast.setIoPri(waitWrkMast.getIoPri()+10.0);
			}else {
			waitWrkMast.setIoPri(9999d);
			}
			if (wrkMast.getIoPri()>23.0){
			wrkMast.setIoPri(wrkMast.getIoPri()-10.0);
			}else {
			wrkMast.setIoPri(13.0d);
			}
			if (wrkMastMapper.updateById(wrkMast)==0){
			News.error("调整优先级失败");
			}
			if (wrkMastMapper.updateById(waitWrkMast)==0){
			News.error("调整优先级失败");
			}else if (waitWrkMast.getWrkSts() != 17){
			flag = true;
			}

			break;
			}
			if (waitWrkMast.getWrkSts() != 17) {
			flag = true;
			}
			}else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			if (null == waitWrkMast) {
			// 生成一笔移库任务工作档、改变浅库位的源库/目标库库位状态
			// 没有作业中的出库任务时，才能生成移库任务
			WrkMast one2 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("crn_no", slave.getId())
			.last(" and wrk_sts in (12,13,14,15,16)"));
			if (one2 == null) {
			moveLocForDeepLoc(slave, shallowLoc);
			// 置顶任务
			wrkMast.setIoPri((double) 9999);
			wrkMastMapper.updateById(wrkMast);
			} else {
			News.error("浅库位阻塞时，且浅库位存在作业中出库任务！工作号={}", one2.getWrkNo());
			}
			break;
			}
			}
			} else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			if (null == waitWrkMast) {
			// 生成一笔移库任务工作档、改变浅库位的源库/目标库库位状态
			// 没有作业中的出库任务时，才能生成移库任务
			WrkMast one2 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("crn_no",slave.getId())
			.last(" and wrk_sts in (12,13,14,15,16)"));
			if(one2==null) {
			moveLocForDeepLoc(slave, shallowLoc);
			}
			flag = true;
			break;
			} else {
			if (waitWrkMast.getWrkSts()!=18) {
			News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			} else {
			if (waitWrkMast.getWrkSts() != 18) {
			News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}

			}

			} else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")) {
			News.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}
			} else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")){
			News.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}

			//20230307 ADD，再加一次判断，当浅库位状态不为O时，不执行当前出库任务
			if (shallowLoc != null && !shallowLoc.getLocSts().equals("O")) {
			News.error("做了浅库位阻塞处理后反复判断，浅库位状态不为O ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", wrkMast.getSourceLocNo(), shallowLoc.getLocNo());
			flag = true;
			break;
			}
			}
			}
			}
			}
			if(flag){
			continue;
			return false;
			}

			// 工作档状态判断
			@@ -1361,6 +1614,10 @@
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 12L) {
			if (Cools.isEmpty(wrkMast.getSteNo()) \|\| wrkMast.getSteNo()==0) {
			News.error("工作号={}即将开始搬运小车但是工作档没有小车号",wrkMast.getWrkNo());
			return false;
			}
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			}
			}
			@@ -1568,6 +1825,102 @@
			}

			/**
			* 库位移转(高频移库，io_type=111)
			*/
			public synchronized void locToLoc111(CrnSlave slave, CrnProtocol crnProtocol){
			// 获取工作档信息
			WrkMast wrkMast = wrkMastMapper.selectLocMove111(slave.getId());
			if (null == wrkMast) {
			return;
			}
			// 过滤
			if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
			News.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
			return;
			}

			// 判断是否已存在小车绑定任务
			BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
			if(basSte == null) return;
			WrkMast one = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("ste_no",basSte.getSteNo())
			.last(" and io_type != 111 and wrk_sts < 10"));
			if(one != null){
			News.error("{}移库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
			return;
			}

			// 获取源库位信息
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceLoc) {
			News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			if (!sourceLoc.getLocSts().equals("R")) {
			return;
			}
			// 获取目标库位信息
			LocMast loc = locMastService.selectById(wrkMast.getLocNo());
			if (null == loc \|\| !loc.getLocSts().equals("S")) {
			News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}
			// 获取堆垛机信息并判断是否可入出
			BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
			if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
			return;
			}

			// // 堆垛机控制过滤
			// if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			// return;
			// }

			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			return;
			}

			// 置顶任务
			wrkMast.setIoPri((double) 9999);
			wrkMastMapper.updateById(wrkMast);

			// 源库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setCommand((short) 0);
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(loc.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("【库位移转】修改工作档状态 11.生成出库ID => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}

			}
			}
			}

			/**
			* 库位移转，回原库位
			*/
			public synchronized void locToLoc17(CrnSlave slave, CrnProtocol crnProtocol){
			@@ -1588,6 +1941,7 @@
			String locNo = Utils.append(row, bay, lev);
			String[] deeplocs = Utils.getDeepLocs(locNo);
			if(!Cools.isEmpty(deeplocs)){
			boolean ret = false;
			for(String deepLocNo : deeplocs) {
			LocMast deepLoc = locMastService.selectById(deepLocNo);
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(deepLocNo);
			@@ -1596,6 +1950,10 @@
			&& !deepLoc.getLocSts().equals("O")
			&& (waitWrkMast!=null && waitWrkMast.getWrkSts()<18)){
			News.error("移库再回库时，深库位组深库位状态为作业中 ===>> deepLoc={},loc_sts={}", deepLoc.getLocNo(), deepLoc.getLocSts());
			if(waitWrkMast.getIoPri()<9999) {//调高优先级
			waitWrkMast.setIoPri(waitWrkMast.getIoPri() + 1);
			wrkMastService.updateById(waitWrkMast);
			}
			flag = true;
			break;
			}
			@@ -1627,7 +1985,40 @@
			throw new CoolException("更新移库回库目标库位状态失败");
			}
			}
			ret = true;
			break;
			}
			}
			if(ret == false && !flag){//深库位都不为O
			LocMast curLoc = locMastService.selectById(locNo);
			if(curLoc != null && curLoc.getLocSts().equals("O")){
			//修改移库工作档
			wrkMast.setSourceLocNo(wrkMast.getLocNo());
			wrkMast.setIoPri((double)9999);
			wrkMast.setWrkSts(2L);
			wrkMast.setLocNo(locNo);
			wrkMast.setSteNo(0);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 17.移库完成 => 2.移库再入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}

			if(curLoc.getLocSts().equals("O")){
			curLoc.setLocSts("S"); // S.入库预约
			curLoc.setModiTime(new Date());
			if (!locMastService.updateById(curLoc)) {
			News.error("双深库位 --- 更新目标库位状态失败！待移转浅库位：" + curLoc.getLocNo());
			throw new CoolException("更新移库回库目标库位状态失败");
			}
			}
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if(sourceLoc.getLocSts().equals("R") \|\| sourceLoc.getLocSts().equals("D")){
			sourceLoc.setLocSts("R"); // R.出库预约
			sourceLoc.setModiTime(new Date());
			if (!locMastService.updateById(sourceLoc)) {
			throw new CoolException("更新移库回库目标库位状态失败");
			}
			}
			}
			}
			}
			@@ -1765,6 +2156,64 @@
			if (wrkMast.getWrkSts() == 3L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			}
			}
			} else { //2023-4-20，最外层库位，搬走小车直接移库
			// 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
			Integer steNo = this.hasCar(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == 0) {
			// 没有其他任务
			if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
			this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
			}
			}
			// 小车搬走
			if (wrkMast.getWrkSts() == 3L) {
			this.carMoveOut(wrkMast, steNo, crnProtocol);
			}
			// 没有小车
			} else {

			// 当前入库库位组没有小车堆垛机则去站点取货入库
			// case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
			// case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == 0) {

			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			return;
			}

			// 堆垛机入库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setCommand((short) 0);
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(loc.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			}
			return;
			}
			}

			}
			}
			}
			@@ -2067,6 +2516,10 @@
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 12L) {
			if (Cools.isEmpty(wrkMast.getSteNo()) \|\| wrkMast.getSteNo()==0) {
			News.error("工作号={}即将开始搬运小车但是工作档没有小车号",wrkMast.getWrkNo());
			return;
			}
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			}
			}
			@@ -2294,6 +2747,10 @@
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			if(steProtocol.getLoad() == 1){
			News.error("小车上方有货，无法下发任务===>>{}", steNo);
			return;
			}
			if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
			// 堆垛机空闲
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() == 0) {
			@@ -2314,18 +2771,35 @@
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {

			if( crnCommand.getSourcePosX() == crnCommand.getDestinationPosX()
			&& crnCommand.getSourcePosY() == crnCommand.getDestinationPosY()
			&& crnCommand.getSourcePosZ() == crnCommand.getDestinationPosZ()){
			//打补丁，如果出现源排列层和目标排列层完全相同时，不给堆垛机发任务，状态直接由3 ==>> 6
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 3.小车待搬 => 4.迁入小车
			// 修改工作档状态 3.小车待搬 => 6.小车待入
			Date now = new Date();
			wrkMast.setWrkSts(4L);
			wrkMast.setWrkSts(6L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 3.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 3.小车待搬 => 4.迁入小车
			Date now = new Date();
			wrkMast.setWrkSts(4L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 3.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			// 出库搬
			@@ -2435,7 +2909,7 @@
			// 充电任务
			WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
			if (wrkCharge == null) {
			News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			News.error("堆垛机处于等待确认且任务完成状态，但未找到充电工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			continue;
			} else {
			// 小车搬至指定库位完成
			@@ -2472,7 +2946,7 @@

			}
			if (wrkMast == null) { continue; }
			if (wrkMast.getIoType() != 11) {
			if (wrkMast.getIoType() != 11 && wrkMast.getIoType() != 111) {
			// 入库 ==>> 货物搬入库
			if (wrkMast.getWrkSts() == 7){
			// 判断是否需要小车入库
			@@ -2616,8 +3090,27 @@
			}
			// 移库 ===>> 堆垛机搬至目标库位组完成
			}
			// 库位移转(高频io_type111)
			} else if(wrkMast.getIoType() == 111) {
			Date now = new Date();
			// 入库 ==>> 货物搬入库
			if (wrkMast.getWrkSts() == 7){
			if (locMastService.isOutMost(wrkMast.getLocNo()) && locMastService.isOutMost(wrkMast.getSourceLocNo())) {
			// ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			News.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			// 库位移转
			} else {
			}else {
			// 入库 ==>> 货物搬入库
			if (wrkMast.getWrkSts() == 7){
			// 判断是否需要小车入库
			@@ -2684,7 +3177,7 @@
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(9999); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式: 去近点等待堆垛机叉取
			steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式: 去待机位避让
			// steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			@@ -2695,6 +3188,36 @@
			News.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			} else if (wrkMast.getWrkSts() == 5) {
			// 5.迁出小车 ==> 6.小车待入
			wrkMast.setWrkSts(6L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(9999); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式: 去近点等待堆垛机叉取
			// steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			News.error("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			if (wrkMast.getWrkSts() == 16) {
			Date now = new Date();
			@@ -2713,7 +3236,7 @@
			String locSts = "";
			// 库位移转判断是否为空板移转
			if (wrkMast.getEmptyMk().equals("N")) {
			locSts = "F";
			locSts = "R";
			// 转移库存明细数据: 库存号由工作档源库位变为目标库位
			if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
			News.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
			@@ -2880,10 +3403,11 @@
			News.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
			}

			if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0 && steProtocol.getStatus() == 10) {
			if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0) {
			News.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}", steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus());
			if (steProtocol.getTaskNo() == 9999) {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记 9999 成功！！，工作号={}", steProtocol.getSteNo(), 9999);
			} else {
			// 查询是否有待入库的任务
			WrkMast wrkMast = wrkMastMapper.selectCarWaiting(steProtocol.getTaskNo().intValue());
			@@ -2900,6 +3424,7 @@
			News.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记 21.准备充电 ===>> 22.小车待搬成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
			}
			} else if (wrkCharge.getWrkSts() == 25) {
			// 25.小车去充电 ===>> 26.等待充电
			@@ -2908,6 +3433,7 @@
			News.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记 25.小车去充电 ===>> 26.等待充电成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
			}
			} else if (wrkCharge.getWrkSts() == 32) {
			// 32.小车走行 ===>> 33.小车待搬
			@@ -2916,6 +3442,7 @@
			News.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记 25.小车去充电 ===>> 26.等待充电成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
			}
			} else if (wrkCharge.getWrkSts() == 36) {
			// 36.小车走行 ===>> 37.演示完成
			@@ -2924,21 +3451,30 @@
			News.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记 36.小车走行 ===>> 37.演示完成成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			}
			}else{
			News.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}，工作档状态={}",
			steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus(), wrkMast.getWrkSts());
			}

			if (wrkMast == null) { continue; }
			switch (wrkMast.getWrkSts().intValue()) {
			case 2:
			// 修改工作档状态 2.设备上走 => 3.小车待搬
			if (Cools.isEmpty(wrkMast.getSteNo()) \|\| wrkMast.getSteNo()==0){
			News.error("修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={} 原因：工作号没小车", wrkMast.getWrkNo());
			break;
			}
			wrkMast.setWrkSts(3L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("ste[id={}] 修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记修改工作档状态 2.设备上走 => 3.小车待搬成功！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
			}
			break;
			case 8:
			@@ -2949,6 +3485,7 @@
			News.error("修改工作档状态 8.小车搬入库 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记修改工作档状态 8.小车搬入库 => 9.入库完成成功！！工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
			}
			break;
			case 11:
			@@ -2979,6 +3516,7 @@
			News.error("修改工作档状态 11.生成出库ID => 12.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记修改工作档状态 11.生成出库ID => 12.小车待搬成功！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
			}
			break;
			case 14:
			@@ -2989,6 +3527,7 @@
			News.error("修改工作档状态 14.小车搬出库 => 15.等待吊车失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("ste[id={}]小车复位标记修改工作档状态 14.小车搬出库 => 15.等待吊车成功！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
			}
			break;
			}
			@@ -3404,17 +3943,27 @@
			}
			ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
			ledCommand.setStaNo(wrkMast.getStaNo());
			ledCommand.setBarcode(wrkMast.getBarcode());
			if (wrkMast.getIoType() != 110) {
			List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());

			wrkDetls.forEach(wrkDetl -> {
			Double total = 0.0;
			EntityWrapper<LocDetl> wrapper = new EntityWrapper<>();
			LocDetl locDetl = locDetlService.selectOne(wrapper.eq("zpallet", wrkDetl.getZpallet()).eq("matnr", wrkDetl.getMatnr()));
			if (Cools.isEmpty(locDetl)) {
			total = wrkDetl.getAnfme();
			} else {
			total = locDetl.getAnfme();
			}
			if (wrkMast.getIoType() == 101) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
			}
			if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() \|\| 0 == wrkDetl.getInspect())) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
			}
			if (wrkMast.getIoType() == 107) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
			}
			});
			}
			@@ -3612,6 +4161,7 @@
			News.error("修改充电任务状态 26.等待充电 ===> 28.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			News.info("修改充电任务状态 26.等待充电 ===> 28.完成充电成功！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			} else {
			@@ -3845,8 +4395,66 @@
			break;
			}
			LocMast loc = null;

			if(shallowLoc.getLocType2()==3){ //低频混直接出库
			// 获取工作号
			int workNo = commonService.getWorkNo(0);
			Date now = new Date();
			// 保存工作档
			WrkMast wrkMast = new WrkMast();
			wrkMast.setWrkNo(workNo);
			wrkMast.setIoTime(now);
			wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
			wrkMast.setIoType(101); // 入出库状态： 101.全板出库
			wrkMast.setIoPri((double) 9999);
			wrkMast.setCrnNo(crn.getId());
			wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
			// wrkMast.setLocNo(loc.getLocNo()); // 目标库位
			wrkMast.setFullPlt("Y"); // 满板
			wrkMast.setPicking("N"); // 拣料
			wrkMast.setExitMk("N"); // 退出
			wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
			wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
			wrkMast.setLinkMis("N");
			wrkMast.setAppeTime(now);
			wrkMast.setModiTime(now);
			int res = wrkMastMapper.insert(wrkMast);
			if (res == 0) {
			throw new CoolException("保存工作档失败");
			}
			// 工作档明细保存
			if (shallowLoc.getLocSts().equals("F")) {
			List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
			for (LocDetl locDetl : locDetls) {
			WrkDetl wrkDetl = new WrkDetl();
			wrkDetl.sync(locDetl);
			wrkDetl.setWrkNo(workNo);
			wrkDetl.setIoTime(new Date());
			wrkDetl.setAnfme(locDetl.getAnfme());
			wrkDetl.setAppeTime(new Date());
			wrkDetl.setModiTime(new Date());
			if (!wrkDetlService.insert(wrkDetl)) {
			throw new CoolException("保存工作档明细失败");
			}
			}
			}
			// 修改源库位状态
			if (shallowLoc.getLocSts().equals("D") \|\| shallowLoc.getLocSts().equals("F")) {
			shallowLoc.setLocSts("R"); // R.出库预约
			shallowLoc.setModiTime(now);
			if (!locMastService.updateById(shallowLoc)) {
			throw new CoolException("更新源库位状态失败");
			}
			} else {
			throw new CoolException("源库位出库失败");
			}

			return;
			}

			List<LocMast> locs = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no",crn.getId())
			.eq("loc_type1",shallowLoc.getLocType1())
			.eq("loc_type2",shallowLoc.getLocType2())
			.eq("loc_sts","O")
			.last(" and row1 in (" + rows + ") order by bay1,lev1"));
			for (LocMast one : locs){
			@@ -3854,32 +4462,33 @@
			\|\| Utils.getBay(one.getLocNo()) != Utils.getBay(shallowLoc.getLocNo())
			\|\| Utils.getLev(one.getLocNo()) != Utils.getLev(shallowLoc.getLocNo())){

			boolean success = true;
			List<String> insideLoc = Utils.getGroupInsideLoc(one.getLocNo());
			for (String inside : insideLoc) {
			if (locMastService.selectById(inside).getLocSts().equals("P")
			\|\| locMastService.selectById(inside).getLocSts().equals("R")
			\|\| locMastService.selectById(inside).getLocSts().equals("S")
			\|\| locMastService.selectById(inside).getLocSts().equals("Q")) {
			success = false; break;
			}
			}

			Integer steNo = this.hasCar(one.getLocNo());
			if (steNo != null) {
			//有小车
			continue;
			}

			if (success) {
			loc = one;
			break;
			// //检测当前库位内侧其他库位是否为D、F、X
			// if (Utils.checkInsideLocIsDFX(one.getLocNo())) {
			// //内侧其他库位不是D、F、X。不能选取该库位
			// continue;
			// }

			//检测当前库位内侧其他库位是否为D、F、X、O
			if (Utils.checkInsideLocIsDFXO(one.getLocNo())) {
			//内侧其他库位不是D、F、X、O。不能选取该库位
			continue;
			}

			loc = one;
			break;
			}
			}

			if (null == loc) {
			News.error("深库位出库 --- 浅库位阻塞异常！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("深库位出库 --- 浅库位阻塞异常！待移转浅库位：" + shallowLoc.getLocNo());
			return;
			// throw new CoolException("深库位出库 --- 浅库位阻塞异常！待移转浅库位：" + shallowLoc.getLocNo());
			}

			// 获取工作号
			@@ -3890,7 +4499,7 @@
			wrkMast.setWrkNo(workNo);
			wrkMast.setIoTime(now);
			wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
			wrkMast.setIoType(11); // 入出库状态： 11.库格移载
			wrkMast.setIoType(111); // 入出库状态： 111.库格移载(高频)
			wrkMast.setIoPri((double) 9999);
			wrkMast.setCrnNo(crn.getId());
			wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
			@@ -4009,4 +4618,51 @@
			}
			}

			public synchronized void automaticallyTurnOffCharging() {
			// 获取当前时间戳
			long timestamp = System.currentTimeMillis();
			Date date = new Date(timestamp);
			TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai");
			java.util.Calendar calendar = java.util.Calendar.getInstance(timeZone);
			calendar.setTime(date);
			int hour = calendar.get(java.util.Calendar.HOUR_OF_DAY);
			if (hour>8 && hour<18){
			for (SteSlave ste : slaveProperties.getSte()) {
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(ste.getId());
			if (Cools.isEmpty(steProtocol, basSte)) { continue; }
			try{
			// 在线空闲无作业标记不在充电
			if (steProtocol.getMode() == 0
			\|\| !steProtocol.statusType.equals(SteStatusType.IDLE)
			\|\| basSte.getPakMk().equals("Y")
			\|\| steProtocol.getChargeStatus() == 0
			) {
			continue;
			}
			if (!steProtocol.isEnable()) {
			continue;
			}
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
			WrkCharge wrkCharge = wrkChargeService.selectWorking(steProtocol.getSteNo().intValue());
			if (wrkCharge == null) {
			if (steProtocol.getChargeStatus() == 1){
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(ste.getId()); // 穿梭车编号
			steCommand.setTaskNo(9999); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE);
			if (!MessageQueue.offer(SlaveType.Ste, ste.getId(), new Task(2, steCommand))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", ste.getId(), JSON.toJSON(steCommand));
			}
			}
			}
			}
			}catch (Exception e){
			News.error("自动关闭充电出错，联系管理员！"+hour+"点;"+ste.getId()+"号小车;");
			}
			}
			}
			}

			}