zy-wcs.git - Gitblit

			@@ -470,13 +470,14 @@
			if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}
			LocMast locMast = null;
			// 修改源库位状态 O.空库位
			LocMast locMast = locMastService.selectById(sourceLocNo);
			locMast.setLocSts("O");
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 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,9 +486,9 @@
			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.getWrkNo() + "任务库存明细转移失败！！！");
			// }

			// 条码设备处理
			barcodeThread.setBarcode("");
			@@ -534,6 +535,31 @@
			}
			}

			}
			}

			/**
			* 盘点货物抵达盘点目标站 wrkMast.sourceLoc P ===>> O
			*/
			public 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()));
			}
			// 修改工作档
			wrkMast.setIoPri(13D);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("更新工作档的优先级失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}
			}
			}

			@@ -675,6 +701,14 @@
			log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}

			//加强判断，只要存在移库任务，说明出库任务未完全结束，不执行入库任务
			WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
			if(!Cools.isEmpty(one)){
			log.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) {
			@@ -869,6 +903,23 @@
			continue;
			}

			//加强判断，确保因出库导致的移库整套任务全部结束后，才能执行下一笔出库任务。只有库位完成移库回去全部任务后，才认为当组出库任务完成
			WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
			if(!Cools.isEmpty(one)){
			//存在移库任务，且在移出中，且移库源库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
			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(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;
			}
			}

			//出库库位不是最外层库位，判断浅库位组是否都为空，或存在库位移转任务
			boolean flag = false;
			if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
			@@ -904,9 +955,12 @@
			flag = true;
			break;
			} else {
			log.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			if (waitWrkMast.getWrkSts()!=18) {
			log.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			flag = true;
			break;
			}

			}
			} else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")){
			log.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
			@@ -1264,6 +1318,11 @@
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
			// 标记移库当前流程
			wrkMast.setMk("O");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
			}
			@@ -1287,43 +1346,54 @@
			return;
			}

			//查找库位
			boolean flag = false;
			String[] deeplocs = Utils.getDeepLocs(wrkMast.getSourceLocNo());
			if(!Cools.isEmpty(deeplocs)){
			for(String deepLocNo : deeplocs) {
			LocMast deepLoc = locMastService.selectById(deepLocNo);
			if (wrkMast.getWrkSts() == 17) {
			//查找库位
			boolean flag = false;
			String[] deeplocs = Utils.getDeepLocs(wrkMast.getSourceLocNo());
			if(!Cools.isEmpty(deeplocs)){
			for(String deepLocNo : deeplocs) {
			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")){
			flag = true;
			break;
			}
			if(deepLoc != null && deepLoc.getLocSts().equals("O")){
			//修改移库工作档
			wrkMast.setSourceLocNo(wrkMast.getLocNo());
			wrkMast.setIoPri((double)9999);
			wrkMast.setWrkSts(2L);
			wrkMast.setLocNo(deepLocNo);
			wrkMast.setSteNo(null);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			if(deepLoc != null && !deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("O")){
			log.error("移库再回库时，深库位组深库位状态为作业中 ===>> deepLoc={},loc_sts={}", deepLoc.getLocNo(), deepLoc.getLocSts());
			flag = true;
			break;
			}

			if(deepLoc.getLocSts().equals("O")){
			deepLoc.setLocSts("S"); // S.入库预约
			deepLoc.setModiTime(new Date());
			if (!locMastService.updateById(deepLoc)) {
			log.error("双深库位 --- 更新目标库位状态失败！待移转浅库位：" + deepLoc.getLocNo());
			throw new CoolException("更新移库回库目标库位状态失败");
			if(deepLoc != null && deepLoc.getLocSts().equals("O")){
			//修改移库工作档
			wrkMast.setSourceLocNo(wrkMast.getLocNo());
			wrkMast.setIoPri((double)9999);
			wrkMast.setWrkSts(2L);
			wrkMast.setLocNo(deepLocNo);
			wrkMast.setSteNo(null);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.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());
			throw new CoolException("更新移库回库目标库位状态失败");
			}
			}
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if(sourceLoc.getLocSts().equals("F")){
			sourceLoc.setLocSts("R"); // R.出库预约
			sourceLoc.setModiTime(new Date());
			if (!locMastService.updateById(sourceLoc)) {
			throw new CoolException("更新移库回库目标库位状态失败");
			}
			}
			break;
			}
			break;
			}
			}
			}
			if(flag){
			return;
			if(flag){
			return;
			}
			}

			// 获取源库位信息
			@@ -1426,6 +1496,11 @@
			if (steThread != null) {
			// 没有其他任务
			if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
			}
			@@ -2325,134 +2400,163 @@
			}
			// 入库 ===>> 迁出小车完成
			}
			// if (wrkMast.getWrkSts() == 16) {
			// Date now = new Date();
			//// if (locMastService.isOutMost(wrkMast.getLocNo())) {
			//// // 16.吊车出库中 ==> 9.入库完成
			//// wrkMast.setWrkSts(9L);
			//// wrkMast.setCrnEndTime(now);
			//// } else {
			//// // 16.吊车出库中 ==> 9.入库完成
			//// wrkMast.setWrkSts(9L);
			//// }
			if (wrkMast.getWrkSts() == 16) {
			Date now = new Date();
			// if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// wrkMast.setWrkSts(17L);
			// }
			// wrkMast.setModiTime(now);
			// // 修改成功后复位堆垛机
			// if (wrkMastMapper.updateById(wrkMast) > 0) {
			// // 堆垛机复位
			// crnThread.setResetFlag(true);
			// } else {
			// log.error("修改工作档状态 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			// }
			// } else if (wrkMast.getWrkSts() == 4) {
			// // 4.迁入小车 ==> 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()) {
			// log.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))) {
			// log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			// }
			// } else {
			// log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			// }
			// // 入库 ===>> 迁出小车完成
			// } else if (wrkMast.getWrkSts() == 7){
			// // 判断是否需要小车入库
			// if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// // ==> 9.入库完成
			// // 16.吊车出库中 ==> 9.入库完成
			// wrkMast.setWrkSts(9L);
			// Date now = new Date();
			// wrkMast.setCrnEndTime(now);
			// wrkMast.setModiTime(now);
			// // 修改成功后复位堆垛机
			// if (wrkMastMapper.updateById(wrkMast) > 0) {
			// // 堆垛机复位
			// crnThread.setResetFlag(true);
			// } else {
			// log.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			// }
			// } else {
			// // 给穿梭车下发命令
			// Integer steNo = wrkMast.getSteNo();
			// SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			// SteProtocol steProtocol = steThread.getSteProtocol();
			// if (steProtocol == null) { continue; }
			// if (steProtocol.isIdle()) {
			// // 命令下发区 --------------------------------------------------------------------------
			// SteCommand steCommand = new SteCommand();
			// steCommand.setSteNo(steNo); // 穿梭车编号
			// 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));
			// } else {
			// // 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			// wrkMast.setWrkSts(8L);
			// Date now = new Date();
			// wrkMast.setCrnEndTime(now);
			// wrkMast.setModiTime(now);
			// if (wrkMastMapper.updateById(wrkMast) > 0) {
			// // 堆垛机复位
			// crnThread.setResetFlag(true);
			// } else {
			// log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			// }
			// }
			// }
			// // 16.吊车出库中 ==> 9.入库完成
			// wrkMast.setWrkSts(9L);
			// }
			// } else if (wrkMast.getWrkSts() == 13) {
			// // 给穿梭车下发命令
			// Integer steNo = wrkMast.getSteNo();
			// SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			// SteProtocol steProtocol = steThread.getSteProtocol();
			// if (steProtocol == null) { continue; }
			// // 穿梭车重新定位排列层
			// if (!steThread.confirmPos()) {
			// log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			// }
			// // 命令下发区 --------------------------------------------------------------------------
			// SteCommand steCommand = new SteCommand();
			// steCommand.setSteNo(steNo); // 穿梭车编号
			// 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));
			// } else {
			// // 13.迁入小车 ==> 14.小车搬出库
			// wrkMast.setWrkSts(14L);
			// Date now = new Date();
			// wrkMast.setCrnEndTime(now);
			// wrkMast.setModiTime(now);
			// // 修改成功后复位堆垛机
			// if (wrkMastMapper.updateById(wrkMast) > 0) {
			// // 堆垛机复位
			// crnThread.setResetFlag(true);
			// } else {
			// log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			// }
			// }
			// }
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			wrkMast.setWrkSts(17L);
			// 默认目标库位是空板
			String locSts = "D";
			// 库位移转判断是否为空板移转
			if (wrkMast.getEmptyMk().equals("N")) {
			locSts = "F";
			// 转移库存明细数据: 库存号由工作档源库位变为目标库位
			if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
			log.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
			continue;
			}
			}
			// 修改源库位状态 ==> O
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null != sourceLoc) {
			sourceLoc.setBarcode("");
			sourceLoc.setLocSts("O");
			sourceLoc.setModiTime(now);
			sourceLoc.setIoTime(now);
			if (!locMastService.updateById(sourceLoc)) {
			log.error("库位移转 ===>> 修改源库位状态失败；[workNo={}],[sourceLoc={}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			}
			}
			// 修改目标库位状态 ==> .locSts
			LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
			locMast.setLocSts(locSts);
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			log.error("");
			}
			}
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else if (wrkMast.getWrkSts() == 4) {
			// 4.迁入小车 ==> 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()) {
			log.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))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			} else if (wrkMast.getWrkSts() == 7){
			// 判断是否需要小车入库
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 给穿梭车下发命令
			Integer steNo = wrkMast.getSteNo();
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (steProtocol.isIdle()) {
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			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));
			} else {
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			} else if (wrkMast.getWrkSts() == 13) {
			// 给穿梭车下发命令
			Integer steNo = wrkMast.getSteNo();
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			// 穿梭车重新定位排列层
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			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));
			} else {
			// 13.迁入小车 ==> 14.小车搬出库
			wrkMast.setWrkSts(14L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			}
			}
			@@ -2544,23 +2648,23 @@
			// 修改工作档状态 11.生成出库ID => 12.小车待搬
			wrkMast.setWrkSts(12L);
			} else {
			// if (Cools.isEmpty(wrkMast.getMk())) {
			// log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
			// } else {
			// if (wrkMast.getMk().equals("I")) {
			// String locNo = wrkMast.getLocNo();
			// if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
			// // 修改工作档状态 11.生成出库ID => 6.小车待入
			// wrkMast.setWrkSts(6L);
			// } else {
			// // 修改工作档状态 11.生成出库ID => 3.小车待搬
			// wrkMast.setWrkSts(3L);
			// }
			// } else if (wrkMast.getMk().equals("O")) {
			// // 修改工作档状态 11.生成出库ID => 12.小车待搬
			// wrkMast.setWrkSts(12L);
			// }
			// }
			if (Cools.isEmpty(wrkMast.getMk())) {
			log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
			} else {
			if (wrkMast.getMk().equals("I")) {
			String locNo = wrkMast.getLocNo();
			if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
			// 修改工作档状态 11.生成出库ID => 6.小车待入
			wrkMast.setWrkSts(6L);
			} else {
			// 修改工作档状态 11.生成出库ID => 3.小车待搬
			wrkMast.setWrkSts(3L);
			}
			} else if (wrkMast.getMk().equals("O")) {
			// 修改工作档状态 11.生成出库ID => 12.小车待搬
			wrkMast.setWrkSts(12L);
			}
			}
			}
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {