zy-wcs.git - Gitblit

			@@ -11,7 +11,6 @@
			import com.zy.asrs.mapper.WrkMastMapper;
			import com.zy.asrs.service.*;
			import com.zy.asrs.utils.Utils;
			import com.zy.asrs.utils.VersionUtils;
			import com.zy.common.model.LocTypeDto;
			import com.zy.common.model.MatDto;
			import com.zy.common.model.SearchLocParam;
			@@ -19,6 +18,7 @@
			import com.zy.common.service.CommonService;
			import com.zy.common.utils.CollectionUtils;
			import com.zy.common.utils.HttpHandler;
			import com.zy.common.utils.News;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.cache.MessageQueue;
			@@ -39,7 +39,6 @@
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			import org.springframework.scheduling.annotation.Async;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;
			@@ -124,7 +123,7 @@
			}
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode)) {
			// log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			// News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			@@ -162,7 +161,7 @@
			// 判断重复工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			if (wrkMast != null) {
			log.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			News.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			continue;
			}

			@@ -203,7 +202,7 @@
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			} else if (code == 700) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			@@ -264,10 +263,10 @@
			wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			News.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			} else {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}
			}
			}
			@@ -311,7 +310,7 @@
			staNo = 203;
			break;
			default:
			log.error("{}任务再入库失败，系统数据异常！", wrkMast.getWrkNo());
			News.error("{}任务再入库失败，系统数据异常！", wrkMast.getWrkNo());
			continue;
			}
			// 更新站点信息且下发plc命令
			@@ -321,7 +320,7 @@
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}
			}
			}
			@@ -331,6 +330,7 @@
			/**
			* 拣料、并板、盘点再入库【第2阶段】
			*/
			@Transactional
			public synchronized void stnToCrnStnPick1(){
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历拣料入库口
			@@ -362,13 +362,13 @@
			if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) {
			wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
			if (null == wrkMast) {
			log.error("{}任务号错误，暂无拣料任务！", staProtocol.getWorkNo());
			News.error("{}任务号错误，暂无拣料任务！", staProtocol.getWorkNo());
			}
			}
			if (staProtocol.getWorkNo() == 9996) {
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
			News.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			@@ -399,7 +399,7 @@
			}
			wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
			if (null == wrkMast) {
			log.error("{}条码错误，暂无拣料任务！", barcode);
			News.error("{}条码错误，暂无拣料任务！", barcode);
			}
			}

			@@ -439,7 +439,7 @@
			// .eq("crn_no", dto.getCrnNo()); // 堆垛机号
			// StaDesc staDesc = staDescService.selectOne(wrapper);
			// if (Cools.isEmpty(staDesc)) {
			// log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			// News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			// continue;
			// }
			// // 堆垛机站点(目标站)
			@@ -455,6 +455,7 @@
			}

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

			// 更新工作档数据状态
			wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
			wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
			@@ -470,14 +471,8 @@
			if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}

			LocMast locMast = null;
			// 修改源库位状态 O.空库位
			// locMast = locMastService.selectById(sourceLocNo);
			// locMast.setLocSts("O");
			// locMast.setModiTime(new Date());
			// if (!locMastService.updateById(locMast)) {
			// throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			// }
			// 修改目标库位状态 Q.拣料/盘点/并板再入库
			locMast = locMastService.selectById(wrkMast.getLocNo());
			locMast.setLocSts("Q");
			@@ -485,10 +480,21 @@
			if (!locMastService.updateById(locMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
			}
			// 库存明细转移
			// if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
			// throw new CoolException(wrkMast.getWrkNo() + "任务库存明细转移失败！！！");
			// }
			// 源库位库存明细转移到目标库位
			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.setModiTime(new Date());
			if (!locMastService.updateById(sourceLocMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			}
			locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
			}

			// 条码设备处理
			barcodeThread.setBarcode("");
			@@ -501,7 +507,7 @@
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}

			} else if (code == 500){
			@@ -511,7 +517,7 @@
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			} else {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			@@ -544,22 +550,85 @@
			public synchronized void pickWrkCompleteStaNo() {
			List<WrkMast> wrkMasts = wrkMastMapper.selectPick17(null, null);
			for (WrkMast wrkMast : wrkMasts) {
			// 修改源库位状态 O.空库位
			LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			if (locMast.getLocSts().equals("P")) {
			locMast.setLocSts("O");
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			}
			locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
			}
			// // 修改源库位状态 O.空库位
			// LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			// if (locMast.getLocSts().equals("P")) {
			// locMast.setLocSts("O");
			// locMast.setModiTime(new Date());
			// if (!locMastService.updateById(locMast)) {
			// throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
			// }
			// locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
			// }
			// 修改工作档
			wrkMast.setIoPri(13D);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("更新工作档的优先级失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			News.error("更新工作档的优先级失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}
			}
			}

			/**
			* 拣料/盘点转全板后，300站任务转100/200站去
			*/
			public synchronized void transPickToFullChangeStn() {
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历拣料出库口
			for (DevpSlave.Sta pickSta : devp.getPickOutSta()) {
			// 获取拣料出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			// && staProtocol.isInEnable()
			&& staProtocol.getWorkNo() > 0
			&& staProtocol.getStaNo().equals(staProtocol.getSiteId().shortValue())
			&& staProtocol.isPakMk()){
			WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
			if(Cools.isEmpty(wrkMast)){
			News.error("拣料/盘点转全板,任务号工作档不存在===>>[任务号:{}]", staProtocol.getWorkNo());
			continue;
			}
			if (wrkMast.getIoType() != 101) { continue; }

			//拣料转全板默认出库站100站，当100站有物时，目标改200站
			Integer staNo = 100;
			StaProtocol staProtocol100 = devpThread.getStation().get(staNo);
			if (staProtocol100 == null) {
			continue;
			} else {
			staProtocol100 = staProtocol100.clone();
			}
			if (staProtocol100.isLoading()) {
			staNo = 200;
			}

			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(staNo.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 {
			wrkMast.setStaNo(staNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("更新工作档的目标站失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}
			}

			}
			}


			}
			}

			@@ -617,7 +686,7 @@
			// 复位堆垛机
			crnThread.setResetFlag(true);
			} else {
			log.error("更新工作档的工作状态为 17.出库完成失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			News.error("更新工作档的工作状态为 17.出库完成失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}

			}
			@@ -638,7 +707,7 @@
			if (crnProtocol == null) { continue; }
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			News.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}
			// 只有当堆垛机空闲并且无任务时才继续执行
			@@ -698,21 +767,21 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}

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

			// 获取工作状态为 2,3,4,5,6 的入库工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep23456(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
			if(null == wrkMast) {
			// log.error("{}站点查询无待入库数据工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
			// News.error("{}站点查询无待入库数据工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
			continue;
			}

			@@ -723,7 +792,7 @@
			.eq("ste_no",basSte.getSteNo())
			.last(" and wrk_sts > 10"));
			if(one1 != null){
			log.error("{}入库任务无法作业，因出库任务已绑定小车!", wrkMast.getWrkNo());
			News.error("{}入库任务无法作业，因出库任务已绑定小车!", wrkMast.getWrkNo());
			continue;
			}

			@@ -739,11 +808,11 @@
			// 获取库位信息
			LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
			if (locMast == null) {
			log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			News.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			continue;
			}
			if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
			log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			News.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			continue;
			}

			@@ -756,12 +825,12 @@
			// ) {
			//
			// } else {
			// log.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
			// News.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
			// continue;
			// }
			// }
			if (null != wrkMastMapper.selectPakout(slave.getId(), null)) {
			log.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
			News.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
			continue;
			}

			@@ -813,7 +882,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 7.吊车入库中
			Date now = new Date();
			@@ -821,7 +890,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			News.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			}
			return true;
			}
			@@ -868,7 +937,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 3.小车待搬 ===>> 7.吊车入库中
			Date now = new Date();
			@@ -876,7 +945,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			return true;
			}
			@@ -924,7 +993,7 @@
			.eq("ste_no",basSte.getSteNo())
			.last(" and wrk_sts < 10"));
			if(one1 != null){
			log.error("{}出库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
			News.error("{}出库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
			continue;
			}

			@@ -932,13 +1001,13 @@
			WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
			if(!Cools.isEmpty(one)){
			//存在移库任务，且在移出中，且移库源库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
			if(wrkMast.getWrkNo() !=15 && one.getWrkSts() > 10 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getSourceLocNo())
			if(one.getWrkSts() > 10 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getSourceLocNo())
			\|\| Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getSourceLocNo())
			\|\| Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getSourceLocNo()))){
			continue;
			}
			//存在移库任务，且在移回中，且移库目标库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
			if(wrkMast.getWrkNo() !=15 && one.getWrkSts() < 11 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getLocNo())
			if(one.getWrkSts() < 11 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getLocNo())
			\|\| Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getLocNo())
			\|\| Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getLocNo()))){
			continue;
			@@ -949,7 +1018,7 @@
			boolean flag = false;
			if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
			WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
			if(wrkMastMove != null){
			if(wrkMastMove != null && wrkMast.getWrkNo() == 11){
			continue;
			}

			@@ -960,14 +1029,14 @@
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			if (null == waitWrkMast) {
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			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) {
			log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			flag = true;
			break;
			@@ -976,19 +1045,25 @@
			} else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			if (null == waitWrkMast) {
			// 生成一笔移库任务工作档、改变浅库位的源库/目标库库位状态
			moveLocForDeepLoc(slave, shallowLoc);
			// 没有作业中的出库任务时，才能生成移库任务
			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) {
			log.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}

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

			// 工作档状态判断
			if (wrkMast.getIoType() < 100 \|\| wrkMast.getSourceStaNo() == null){
			log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			News.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			continue;
			}
			// 获取源库位信息
			LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
			if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
			log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			continue;
			}
			// 获取堆垛机出库站信息
			@@ -1022,7 +1097,7 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}
			// 判断堆垛机出库站状态
			@@ -1037,7 +1112,7 @@

			// 过滤
			if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
			log.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
			News.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
			continue;
			}

			@@ -1066,7 +1141,7 @@
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 16.吊车出库中
			Date now = new Date();
			@@ -1074,7 +1149,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			return true;
			}
			@@ -1110,9 +1185,9 @@
			steCommand.setMemo("11==>14小车搬出库任务，任务号"+wrkMast.getWrkNo()+"");

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			log.info("穿梭车命令下发成功(11==>14小车搬出库任务)，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.info("穿梭车命令下发成功(11==>14小车搬出库任务)，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			// 修改工作档状态 11.生成出库ID => 14.小车搬出库
			Date now = new Date();
			wrkMast.setWrkSts(14L);
			@@ -1120,7 +1195,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1145,7 +1220,7 @@
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 15.等待吊车 => 16.吊车出库中
			Date now = new Date();
			@@ -1153,7 +1228,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			return true;
			}
			@@ -1211,7 +1286,7 @@
			}
			// 过滤
			if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
			log.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
			News.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
			return;
			}

			@@ -1222,14 +1297,14 @@
			.eq("ste_no",basSte.getSteNo())
			.last(" and io_type != 11 and wrk_sts < 10"));
			if(one != null){
			log.error("{}移库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
			News.error("{}移库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
			return;
			}

			// 获取源库位信息
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceLoc) {
			log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			@@ -1239,7 +1314,7 @@
			// 获取目标库位信息
			LocMast loc = locMastService.selectById(wrkMast.getLocNo());
			if (null == loc \|\| !loc.getLocSts().equals("S")) {
			log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}
			// 获取堆垛机信息并判断是否可入出
			@@ -1280,7 +1355,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 16.吊车出库中
			Date now = new Date();
			@@ -1288,7 +1363,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("【库位移转】修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("【库位移转】修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}

			@@ -1324,7 +1399,7 @@
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 14.小车搬出库
			Date now = new Date();
			@@ -1333,7 +1408,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1358,7 +1433,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 15.等待吊车 => 16.吊车出库中
			Date now = new Date();
			@@ -1366,7 +1441,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			return;
			}
			@@ -1381,7 +1456,7 @@
			// 标记移库当前流程
			wrkMast.setMk("O");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
			@@ -1421,7 +1496,7 @@
			LocMast deepLoc = locMastService.selectById(deepLocNo);
			// WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(deepLocNo);
			if(deepLoc != null && !deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("O")){
			log.error("移库再回库时，深库位组深库位状态为作业中 ===>> deepLoc={},loc_sts={}", deepLoc.getLocNo(), deepLoc.getLocSts());
			News.error("移库再回库时，深库位组深库位状态为作业中 ===>> deepLoc={},loc_sts={}", deepLoc.getLocNo(), deepLoc.getLocSts());
			flag = true;
			break;
			}
			@@ -1434,19 +1509,19 @@
			wrkMast.setSteNo(0);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 17.移库完成 => 2.移库再入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 17.移库完成 => 2.移库再入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}

			if(deepLoc.getLocSts().equals("O")){
			deepLoc.setLocSts("S"); // S.入库预约
			deepLoc.setModiTime(new Date());
			if (!locMastService.updateById(deepLoc)) {
			log.error("双深库位 --- 更新目标库位状态失败！待移转浅库位：" + deepLoc.getLocNo());
			News.error("双深库位 --- 更新目标库位状态失败！待移转浅库位：" + deepLoc.getLocNo());
			throw new CoolException("更新移库回库目标库位状态失败");
			}
			}
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if(sourceLoc.getLocSts().equals("F")){
			if(sourceLoc.getLocSts().equals("F") \|\| sourceLoc.getLocSts().equals("D")){
			sourceLoc.setLocSts("R"); // R.出库预约
			sourceLoc.setModiTime(new Date());
			if (!locMastService.updateById(sourceLoc)) {
			@@ -1465,7 +1540,7 @@
			// 获取源库位信息
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceLoc) {
			log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			@@ -1476,7 +1551,7 @@
			// 获取目标库位信息
			LocMast loc = locMastService.selectById(wrkMast.getLocNo());
			if (null == loc \|\| !loc.getLocSts().equals("S")) {
			log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}

			@@ -1515,17 +1590,18 @@
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			if(steProtocol.getLoca()==3 \|\| steProtocol.getLoca()==4){
			//小车已经在待机位时，无需下发到待机位任务，直接更新状态微3，同时绑定小车
			wrkMast.setWrkSts(3L);
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			}
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			// if(steProtocol.getLoca()==3 \|\| steProtocol.getLoca()==4){
			// //小车已经在待机位时，无需下发到待机位任务，直接更新状态微3，同时绑定小车
			// wrkMast.setWrkSts(3L);
			// wrkMast.setSteNo(steNo);
			// wrkMast.setModiTime(new Date());
			// if (wrkMastMapper.updateById(wrkMast) == 0) {
			// News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			// }
			// } else {
			// this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			// }
			}
			}
			// 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入 ===>> 7.吊车入库中
			@@ -1554,7 +1630,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 3.小车待搬 ===>> 7.吊车入库中
			Date now = new Date();
			@@ -1562,7 +1638,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			return;
			}
			@@ -1579,7 +1655,7 @@
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
			@@ -1607,7 +1683,7 @@
			// 获取源库位信息
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceLoc) {
			log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			@@ -1617,7 +1693,7 @@
			// 获取目标库位信息
			LocMast loc = locMastService.selectById(wrkMast.getLocNo());
			if (null == loc) {
			log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}
			// 获取堆垛机信息并判断是否可入出
			@@ -1660,7 +1736,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 16.吊车出库中
			Date now = new Date();
			@@ -1668,7 +1744,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("【库位移转】修改工作档状态 11.生成出库ID => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("【库位移转】修改工作档状态 11.生成出库ID => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}

			@@ -1681,7 +1757,7 @@
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			}
			@@ -1711,7 +1787,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 6.小车待入 ===>> 7.吊车入库中
			Date now = new Date();
			@@ -1719,7 +1795,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1732,7 +1808,7 @@
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
			@@ -1776,7 +1852,7 @@
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 14.小车搬出库
			Date now = new Date();
			@@ -1785,7 +1861,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1812,7 +1888,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 15.等待吊车 => 16.吊车出库中
			Date now = new Date();
			@@ -1820,7 +1896,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
			}
			@@ -1859,7 +1935,7 @@
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 6.小车待入 ===>> 7.吊车入库中
			Date now = new Date();
			@@ -1867,7 +1943,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1884,7 +1960,7 @@
			// 标记移库当前流程
			wrkMast.setMk("O");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
			@@ -1977,14 +2053,14 @@
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			log.error("穿梭车命令下发成功让小车从远点 ====>> 待机位,绑定穿梭车,IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发成功让小车从远点 ====>> 待机位,绑定穿梭车,IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
			// 修改工作档状态绑定穿梭车
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1997,7 +2073,7 @@
			if (steProtocol == null) { return; }

			if (!basSteService.updatePakMk(steNo, "Y")) {
			log.error("修改穿梭车作业状态失败！！，穿梭车={}", steNo);
			News.error("修改穿梭车作业状态失败！！，穿梭车={}", steNo);
			return;
			}

			@@ -2018,13 +2094,13 @@
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态绑定穿梭车
			wrkCharge.setSteNo(steNo);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			@@ -2058,14 +2134,14 @@
			steCommand.setMemo("绑定小车号，让小车从远点 ====>> 移动到近点");

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			log.info("穿梭车命令下发成功(让小车从远点==>>移动到近点)，IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
			News.info("穿梭车命令下发成功(让小车从远点==>>移动到近点)，IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
			// 修改工作档状态绑定穿梭车
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2099,13 +2175,13 @@
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态绑定穿梭车
			wrkCharge.setSteNo(steNo);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			@@ -2119,7 +2195,7 @@
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			if (steProtocol.isIdle()) {
			if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
			// 堆垛机空闲
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() == 0) {
			LocMast locMast;
			@@ -2140,7 +2216,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			@@ -2150,7 +2226,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			// 出库搬
			@@ -2170,7 +2246,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			@@ -2180,7 +2256,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 12.小车待搬 => 13.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 12.小车待搬 => 13.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2198,13 +2274,13 @@
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			// 穿梭车空闲
			if (steProtocol.isIdle()) {
			if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
			// 堆垛机空闲
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() == 0) {

			BasSte basSte = basSteService.selectById(steNo);
			if (basSte == null) {
			log.error("{}号穿梭车在数据库不存在！！！", steNo);
			News.error("{}号穿梭车在数据库不存在！！！", steNo);
			return;
			}
			String idleLocNo = basSte.getIdleLoc();
			@@ -2223,7 +2299,7 @@
			crnCommand.setDestinationPosY((short) Utils.getBay(idleLocNo)); // 目标库位列
			crnCommand.setDestinationPosZ((short) Utils.getLev(idleLocNo)); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(idleLocNo), Utils.getBay(idleLocNo), Utils.getLev(idleLocNo));
			@@ -2233,7 +2309,7 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬 => 5.迁出小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬 => 5.迁出小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2260,7 +2336,7 @@
			// 充电任务
			WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
			if (wrkCharge == null) {
			log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			continue;
			} else {
			// 小车搬至指定库位完成
			@@ -2268,28 +2344,28 @@
			// 23.吊车搬运 ===>> 24.小车到达
			wrkCharge.setWrkSts(24L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 34) {
			// 34.吊车搬运 ===>> 35.小车就绪
			wrkCharge.setWrkSts(35L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 34.吊车搬运 ===>> 35.小车就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 34.吊车搬运 ===>> 35.小车就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			}
			@@ -2312,7 +2388,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 给穿梭车下发命令
			@@ -2327,7 +2403,7 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			@@ -2338,7 +2414,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2357,7 +2433,7 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			@@ -2369,10 +2445,10 @@
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			} else if (wrkMast.getWrkSts() == 5) {
			@@ -2388,7 +2464,7 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			@@ -2400,10 +2476,10 @@
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 出库 ===>> 迁入小车完成
			} else if (wrkMast.getWrkSts() == 13) {
			@@ -2414,7 +2490,7 @@
			if (steProtocol == null) { continue; }
			// 穿梭车重新定位排列层
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			@@ -2423,9 +2499,9 @@
			steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 搬出库
			steCommand.setMemo("出库 ===>> 迁入小车完成");
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			log.info("穿梭车命令下发成功，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.info("穿梭车命令下发成功，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			// 13.迁入小车 ==> 14.小车搬出库
			wrkMast.setWrkSts(14L);
			Date now = new Date();
			@@ -2436,7 +2512,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			// 移库 ===>> 堆垛机搬至目标库位组完成
			@@ -2457,7 +2533,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 给穿梭车下发命令
			@@ -2472,7 +2548,7 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			@@ -2483,7 +2559,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2502,7 +2578,7 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			@@ -2514,10 +2590,10 @@
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			}
			@@ -2541,12 +2617,14 @@
			locSts = "F";
			// 转移库存明细数据: 库存号由工作档源库位变为目标库位
			if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
			log.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
			News.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
			continue;
			}
			} else {
			locSts = "D";
			}
			if(Cools.isEmpty(locSts)){
			log.error("库位移转 ===>> 库存状态为空；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
			News.error("库位移转 ===>> 库存状态为空；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
			continue;
			}

			@@ -2558,7 +2636,7 @@
			sourceLoc.setModiTime(now);
			sourceLoc.setIoTime(now);
			if (!locMastService.updateById(sourceLoc)) {
			log.error("库位移转 ===>> 修改源库位状态失败；[workNo={}],[sourceLoc={}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			News.error("库位移转 ===>> 修改源库位状态失败；[workNo={}],[sourceLoc={}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			}
			}
			// 修改目标库位状态 ==> .locSts
			@@ -2566,7 +2644,7 @@
			locMast.setLocSts(locSts);
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			log.error("");
			News.error("");
			}
			}
			wrkMast.setModiTime(now);
			@@ -2575,7 +2653,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else if (wrkMast.getWrkSts() == 4) {
			// 4.迁入小车 ==> 6.小车待入
			@@ -2590,7 +2668,7 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			@@ -2602,10 +2680,10 @@
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			} else if (wrkMast.getWrkSts() == 7){
			@@ -2621,7 +2699,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 给穿梭车下发命令
			@@ -2636,7 +2714,7 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			@@ -2647,7 +2725,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2660,7 +2738,7 @@
			if (steProtocol == null) { continue; }
			// 穿梭车重新定位排列层
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			@@ -2668,7 +2746,7 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 搬出库
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 13.迁入小车 ==> 14.小车搬出库
			wrkMast.setWrkSts(14L);
			@@ -2680,7 +2758,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2700,11 +2778,11 @@
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (steProtocol.getWaiting() && steProtocol.getTaskNo() == 0){
			log.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
			News.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
			}

			if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0 && steProtocol.getStatus() == 10) {
			log.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}", steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus());
			News.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}", steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus());
			if (steProtocol.getTaskNo() == 9999) {
			steThread.setResetFlag(true);
			} else {
			@@ -2720,7 +2798,7 @@
			// 21.准备充电 ===>> 22.小车待搬
			wrkCharge.setWrkSts(22L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2728,7 +2806,7 @@
			// 25.小车去充电 ===>> 26.等待充电
			wrkCharge.setWrkSts(26L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2736,7 +2814,7 @@
			// 32.小车走行 ===>> 33.小车待搬
			wrkCharge.setWrkSts(33L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2744,7 +2822,7 @@
			// 36.小车走行 ===>> 37.演示完成
			wrkCharge.setWrkSts(37L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2759,7 +2837,7 @@
			wrkMast.setWrkSts(3L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2769,7 +2847,7 @@
			wrkMast.setWrkSts(9L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 8.小车搬入库 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 8.小车搬入库 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2780,7 +2858,7 @@
			wrkMast.setWrkSts(12L);
			} else {
			if (Cools.isEmpty(wrkMast.getMk())) {
			log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
			News.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
			} else {
			if (wrkMast.getMk().equals("I")) {
			String locNo = wrkMast.getLocNo();
			@@ -2799,7 +2877,7 @@
			}
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 12.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2809,7 +2887,7 @@
			wrkMast.setWrkSts(15L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 14.小车搬出库 => 15.等待吊车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 14.小车搬出库 => 15.等待吊车失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2828,7 +2906,7 @@
			this.recCrnErr();
			this.recSteErr();
			} catch (Exception e) {
			log.error("recErr fail", e);
			News.error("recErr fail", e);
			}
			}

			@@ -2880,7 +2958,7 @@
			"任务中异常" // 备注
			);
			if (!basErrLogService.insert(basErrLog)) {
			log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			News.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			}
			}
			} else {
			@@ -2890,7 +2968,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basErrLogService.updateById(latest)) {
			log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			News.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			}
			}
			}
			@@ -2927,7 +3005,7 @@
			"无任务异常" // 备注
			);
			if (!basErrLogService.insert(basErrLog)) {
			log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			News.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			}
			}
			// 无异常
			@@ -2938,7 +3016,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basErrLogService.updateById(latest)) {
			log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			News.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			}
			}
			}
			@@ -2994,7 +3072,7 @@
			"任务中异常" // 备注
			);
			if (!basSteErrLogService.insert(basSteErrLog)) {
			log.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			News.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			}
			}
			} else {
			@@ -3004,7 +3082,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basSteErrLogService.updateById(latest)) {
			log.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			News.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			}
			}
			}
			@@ -3041,7 +3119,7 @@
			"无任务异常" // 备注
			);
			if (!basSteErrLogService.insert(basSteErrLog)) {
			log.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			News.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			}
			}
			// 无异常
			@@ -3052,7 +3130,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basSteErrLogService.updateById(latest)) {
			log.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			News.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			}
			}
			}
			@@ -3092,7 +3170,7 @@
			if (barcodeThread != null) {
			String barcode0 = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode0)) {
			// log.info("{}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode0);
			// News.info("{}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode0);
			if(!"NG".endsWith(barcode0) && !"NoRead".equals(barcode0) && !"empty".equals(barcode0)) {
			barcode = barcode0;
			}
			@@ -3139,7 +3217,7 @@
			MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(3, errorMsg));
			}
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}
			} catch (Exception e) {
			e.printStackTrace();
			@@ -3199,7 +3277,7 @@
			ledCommand.setEmptyMk(true);
			break;
			default:
			log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
			News.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
			break;
			}
			ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
			@@ -3230,7 +3308,7 @@
			// 命令下发 -------------------------------------------------------------------------------
			if (!commands.isEmpty()) {
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			continue;
			}
			}
			@@ -3279,7 +3357,7 @@
			// led显示默认内容
			if (reset) {
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			}
			}
			}
			@@ -3322,7 +3400,7 @@
			wrkCharge.setLocNo(idleLoc);
			wrkCharge.setMemo("charge");
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
			News.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
			continue;
			}

			@@ -3332,7 +3410,7 @@
			wrkCharge.setWrkSts(24L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			this.letCarBeWaiting(wrkCharge, ste.getId());
			@@ -3363,7 +3441,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			@@ -3373,7 +3451,7 @@
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改工作档状态 22.小车待搬 => 23.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}

			@@ -3387,7 +3465,7 @@
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findChargeByLoc(steProtocol.getRow().intValue()));
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 24.小车到达 ===> 25.小车去充电
			wrkCharge.setWrkSts(25L);
			@@ -3395,7 +3473,7 @@
			wrkCharge.setCrnEndTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 24.小车到达 ===> 25.小车去充电失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 24.小车到达 ===> 25.小车去充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			@@ -3409,18 +3487,18 @@
			// 修改工作档状态 26.等待充电 ===> 28.完成充电
			wrkCharge.setWrkSts(28L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 26.等待充电 ===> 28.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 26.等待充电 ===> 28.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			}
			} else {
			log.error("获取充电桩号失败，解析库位：{}", wrkCharge.getLocNo());
			News.error("获取充电桩号失败，解析库位：{}", wrkCharge.getLocNo());
			}
			}
			}
			} catch (Exception e) {
			log.error("fail", e);
			News.error("fail", e);
			}
			}
			}
			@@ -3512,7 +3590,7 @@
			}
			}

			log.info("{}号堆垛机对{}库位进行演示", crn.getId(), locNo);
			News.info("{}号堆垛机对{}库位进行演示", crn.getId(), locNo);

			String sourceLocNo = Utils.getLocNo(steProtocol.getRow(), steProtocol.getBay(), steProtocol.getLev());

			@@ -3526,7 +3604,7 @@
			wrkCharge.setLocNo(locNo);
			wrkCharge.setMemo("demo");
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("生成演示任务失败，堆垛机号：{}，小车：{}，源库位：{}，目标库位：{}", crn.getId(), steNo, sourceLocNo, locNo);
			News.error("生成演示任务失败，堆垛机号：{}，小车：{}，源库位：{}，目标库位：{}", crn.getId(), steNo, sourceLocNo, locNo);
			}
			}
			}
			@@ -3553,7 +3631,7 @@
			wrkCharge.setWrkSts(32L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务{}工作档 31.生成演示ID ==>> 32.小车走行失败!", wrkCharge.getWrkNo());
			News.error("修改演示任务{}工作档 31.生成演示ID ==>> 32.小车走行失败!", wrkCharge.getWrkNo());
			}
			// 33.小车待搬
			} else if (wrkCharge.getWrkSts() == 33L) {
			@@ -3572,7 +3650,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			@@ -3582,7 +3660,7 @@
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务{}工作档 33.小车待搬 => 34.吊车搬运失败!", wrkCharge.getWrkNo());
			News.error("修改演示任务{}工作档 33.小车待搬 => 34.吊车搬运失败!", wrkCharge.getWrkNo());
			}
			}
			// 35.小车就绪
			@@ -3590,7 +3668,7 @@

			int steNo = steProtocol.getSteNo().intValue();
			if (!basSteService.updatePakMk(steNo, "Y")) {
			log.error("修改穿梭车作业状态失败！！，穿梭车={}", steNo);
			News.error("修改穿梭车作业状态失败！！，穿梭车={}", steNo);
			return;
			}

			@@ -3613,13 +3691,13 @@
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 35.小车就绪 => 36.小车走行
			wrkCharge.setWrkSts(36L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务{}工作档 35.小车就绪 => 36.小车走行失败!", wrkCharge.getWrkNo());
			News.error("修改演示任务{}工作档 35.小车就绪 => 36.小车走行失败!", wrkCharge.getWrkNo());
			}
			}
			}
			@@ -3659,7 +3737,7 @@
			}

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

			@@ -3725,7 +3803,7 @@
			throw new CoolException("移转失败");
			}
			} catch (Exception e) {
			log.error("深库位阻塞，对浅库位进行移转失败", e);
			News.error("深库位阻塞，对浅库位进行移转失败", e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}