zy-wcs.git - Gitblit

			@@ -786,18 +786,18 @@
			return;
			}
			// 获取源库位信息
			LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceSta) {
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceLoc) {
			log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("S")) {
			if (!sourceLoc.getLocSts().equals("R") && !sourceLoc.getLocSts().equals("S")) {
			return;
			}
			// 获取目标库位信息
			LocMast sta = locMastService.selectById(wrkMast.getLocNo());
			if (null == sta) {
			LocMast loc = locMastService.selectById(wrkMast.getLocNo());
			if (null == loc) {
			log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}
			@@ -817,8 +817,6 @@
			return;
			}



			// 源库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
			// 目标库位 ===>> 最外层库位
			@@ -829,12 +827,12 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(sta.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(sta.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(sta.getLev1().shortValue()); // 目标库位层
			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))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			@@ -848,25 +846,210 @@
			}
			}
			} else {
			Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			}
			// 堆垛机将货放至小车上 6.小车待入 ===>> 7.吊车入库中
			if (wrkMast.getWrkSts() == 6L) {
			// 小车处于空闲
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			if (steProtocol.isIdle()) {



			// 已经存在吊车执行任务时，则过滤
			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.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(loc.getRow1()).shortValue()); // 目标库位排
			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));
			} else {
			// 修改工作档状态 6.小车待入 ===>> 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			} else {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 寻找当前堆垛机对应的小车
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
			}
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 3L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			}
			}
			}

			} else {
			// 当前组库位是否有穿梭车
			Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
			// 有小车
			if (steNo != null) {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {

			// 给穿梭车下发命令让其将货物挪至堆垛机搬运点
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			if (steProtocol.isIdle()) {

			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 去近点等待堆垛机叉取

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			steCommand.setBay(steProtocol.getBay());
			steCommand.setLev(steProtocol.getLev());

			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 14.小车搬出库
			Date now = new Date();
			wrkMast.setWrkSts(14L);
			wrkMast.setSteNo(steNo);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			if (wrkMast.getWrkSts() == 15L) {
			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			return;
			}

			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// 堆垛机出库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(loc.getRow1()).shortValue()); // 目标库位排
			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));
			} else {
			// 修改工作档状态 15.等待吊车 => 16.吊车出库中
			Date now = new Date();
			wrkMast.setWrkSts(16L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
			}
			} else {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			}
			// 堆垛机将货放至小车上 6.小车待入 ===>> 7.吊车入库中
			if (wrkMast.getWrkSts() == 6L) {
			// 小车处于空闲
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { return; }
			if (steProtocol.isIdle()) {

			// 已经存在吊车执行任务时，则过滤
			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.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(loc.getRow1()).shortValue()); // 目标库位排
			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));
			} else {
			// 修改工作档状态 6.小车待入 ===>> 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}

			}

			}
			} else {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 寻找最近的小车
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			// 标记移库当前流程
			wrkMast.setMk("O");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
			}
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 12L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			}
			}
			}











			}

			/**
			@@ -993,7 +1176,7 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(steProtocol.getRow()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			@@ -1022,7 +1205,7 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(steProtocol.getRow()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			@@ -1118,12 +1301,56 @@
			log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			continue;
			}
			// 入库 ==>> 货物搬入库
			if (wrkMast.getWrkSts() == 7){
			// 判断是否需要小车入库
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			if (wrkMast.getIoType() != 11) {
			// 入库 ==>> 货物搬入库
			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() == 4) {
			// 4.迁入小车 ==> 6.小车待入
			wrkMast.setWrkSts(6L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			@@ -1131,134 +1358,187 @@
			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("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 入库 ===>> 迁出小车完成
			} 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()) {
			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("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", 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 (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));
			// 穿梭车重新定位排列层
			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 {
			// 修改工作档状态 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());
			}
			log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", 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() == 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()) {
			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("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", 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 (steProtocol.isIdle()) {
			// 穿梭车重新定位排列层
			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);
			// 库位移转
			} else {
			if (wrkMast.getWrkSts() == 16) {
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// 16.吊车出库中 ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			wrkMast.setCrnEndTime(now);
			} else {
			// 16.吊车出库中 ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			}
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			log.error("修改工作档状态 16.吊车出库中失败！！，工作号={}", 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());
			}
			}
			}
			// }
			}
			}
			}
			@@ -1304,8 +1584,28 @@
			}
			break;
			case 11:
			// 修改工作档状态 11.生成出库ID => 12.小车待搬
			wrkMast.setWrkSts(12L);
			if (wrkMast.getIoType() != 11) {
			// 修改工作档状态 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);
			}
			}
			}
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());