zy-wcs.git - Gitblit

			@@ -15,6 +15,7 @@
			import com.zy.common.model.MatDto;
			import com.zy.common.model.SearchLocParam;
			import com.zy.common.model.StartupDto;
			import com.zy.common.model.enums.WrkChargeType;
			import com.zy.common.service.CommonService;
			import com.zy.common.utils.CollectionUtils;
			import com.zy.common.utils.HttpHandler;
			@@ -38,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;
			@@ -117,6 +117,54 @@
			&& !staProtocol.isEmptyMk() && (workNo == 0 \|\| (workNo >= 9990 && workNo <= 9999))
			&& staProtocol.isPakMk()) {

			// 尺寸检测异常
			boolean back = false;
			String errMsg = "";
			if (staProtocol.isFrontErr()) {
			errMsg = "前超限";
			back = true;
			}
			if (!back && staProtocol.isBackErr()) {
			errMsg = "后超限";
			back = true;
			}
			if (!back && staProtocol.isHighErr()) {
			errMsg = "高超限";
			back = true;
			}
			if (!back && staProtocol.isLeftErr()) {
			errMsg = "左超限";
			back = true;
			}
			if (!back && staProtocol.isRightErr()) {
			errMsg = "右超限";
			back = true;
			}
			if (!back && staProtocol.isWeightErr()) {
			errMsg = "超重";
			back = true;
			}
			if (!back && staProtocol.isBarcodeErr()) {
			errMsg = "扫码失败";
			back = true;
			}

			// 退回
			if (back) {
			log.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

			// led 异常显示
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
			}
			continue;
			}

			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			if (barcodeThread == null) {
			@@ -126,7 +174,7 @@
			if(!Cools.isEmpty(barcode)) {
			// log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -140,7 +188,7 @@
			continue;
			}
			} else {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -155,16 +203,16 @@
			}

			// 过滤盘点/拣料/并板任务
			if (null != wrkMastMapper.selectPickStepByBarcode(barcode)) {
			continue;
			}
			// if (null != wrkMastMapper.selectPickStepByBarcode(barcode)) {
			// continue;
			// }

			// 判断重复工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			if (wrkMast != null) {
			log.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			continue;
			}
			// WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			// if (wrkMast != null) {
			// log.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			// continue;
			// }

			try {
			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			@@ -172,7 +220,7 @@
			param.setBarcode(barcode);
			param.setIoType(1);
			param.setSourceStaNo(inSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			// param.setLocType1(locTypeDto.getLocType1());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			@@ -203,7 +251,7 @@
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			} else if (code == 700) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -227,6 +275,7 @@
			* wms入库
			* 入库站，根据条码扫描生成入库工作档，工作状态 1 ==>> 2
			*/
			@Deprecated
			public void generateStoreWrkFile0() {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			@@ -246,6 +295,55 @@
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && (workNo == 0 \|\| (workNo >= 9990 && workNo <= 9999))
			&& staProtocol.isPakMk()) {

			// 尺寸检测异常
			boolean back = false;
			String errMsg = "";
			if (staProtocol.isFrontErr()) {
			errMsg = "前超限";
			back = true;
			}
			if (!back && staProtocol.isBackErr()) {
			errMsg = "后超限";
			back = true;
			}
			if (!back && staProtocol.isHighErr()) {
			errMsg = "高超限";
			back = true;
			}
			if (!back && staProtocol.isLeftErr()) {
			errMsg = "左超限";
			back = true;
			}
			if (!back && staProtocol.isRightErr()) {
			errMsg = "右超限";
			back = true;
			}
			if (!back && staProtocol.isWeightErr()) {
			errMsg = "超重";
			back = true;
			}
			if (!back && staProtocol.isBarcodeErr()) {
			errMsg = "扫码失败";
			back = true;
			}

			// 退回
			if (back) {
			log.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

			// led 异常显示
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
			}
			continue;
			}

			// 判断重复工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep11(inSta.getStaNo());
			if (wrkMast == null) { continue; }
			@@ -273,63 +371,9 @@
			}

			/**
			* 拣料、并板、盘点再入库【第1阶段】
			* 拣料、并板、盘点再入库
			*/
			public synchronized void stnToCrnStnPick0(){
			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.isPakMk()) {
			WrkMast wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
			if (wrkMast == null) {
			// 无拣料数据
			continue;
			}
			short staNo;
			switch (wrkMast.getSourceStaNo()) {
			case 104:
			case 108:
			staNo = 103;
			break;
			case 204:
			case 208:
			staNo = 203;
			break;
			default:
			log.error("{}任务再入库失败，系统数据异常！", wrkMast.getWrkNo());
			continue;
			}
			// 更新站点信息且下发plc命令
			// staProtocol.setWorkNo((short) 9994);
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(staNo);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}
			}
			}
			}
			}

			/**
			* 拣料、并板、盘点再入库【第2阶段】
			*/
			public synchronized void stnToCrnStnPick1(){
			public synchronized void stnToCrnStnPick(){
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历拣料入库口
			for (DevpSlave.Sta pickSta : devp.getPickInSta()) {
			@@ -346,65 +390,63 @@
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			// 0 - 9990 或者 9996
			&& ((staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) \|\| staProtocol.getWorkNo() == 9996)
			&& (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990)
			&& staProtocol.getStaNo().equals(staProtocol.getSiteId().shortValue())
			&& staProtocol.isPakMk()){

			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
			if (barcodeThread == null) {
			continue;
			}
			// BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
			// if (barcodeThread == null) {
			// continue;
			// }

			WrkMast wrkMast = null;
			if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) {
			wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
			if (null == wrkMast) {
			log.error("{}任务号错误，暂无拣料任务！", staProtocol.getWorkNo());
			}
			}
			if (staProtocol.getWorkNo() == 9996) {
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

			// led 异常显示
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			if (ledThread != null) {
			String errorMsg = "扫码失败，请重试";
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			continue;
			}
			} else {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

			// led 异常显示
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			if (ledThread != null) {
			String errorMsg = "扫码失败，请重试";
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			continue;
			}
			wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
			if (null == wrkMast) {
			log.error("{}条码错误，暂无拣料任务！", barcode);
			}
			}

			if (wrkMast == null) {
			// 无拣料数据
			} else {
			continue;
			}
			// if (staProtocol.getWorkNo() == 9996) {
			// String barcode = barcodeThread.getBarcode();
			// if(!Cools.isEmpty(barcode)) {
			// log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
			// if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)) {
			// staProtocol.setWorkNo((short) 32002);
			// staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			//
			// // led 异常显示
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			// if (ledThread != null) {
			// String errorMsg = "扫码失败，请重试";
			// MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			// }
			// continue;
			// }
			// } else {
			// staProtocol.setWorkNo((short) 32002);
			// staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			//
			// // led 异常显示
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			// if (ledThread != null) {
			// String errorMsg = "扫码失败，请重试";
			// MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			// }
			// continue;
			// }
			// wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
			// if (null == wrkMast) {
			// log.error("{}条码错误，暂无拣料任务！", barcode);
			// }
			// }
			if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
			\|\| Cools.isEmpty(wrkMast.getStaNo()) \|\| Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
			continue;
			@@ -417,7 +459,7 @@
			param.setWrkNo(wrkMast.getWrkNo());
			param.setIoType(wrkMast.getIoType());
			param.setSourceStaNo(pickSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			// param.setLocType1(locTypeDto.getLocType1());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			@@ -468,27 +510,6 @@
			if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}
			// 修改源库位状态 O.空库位
			LocMast 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");
			locMast.setModiTime(new Date());
			if (!locMastService.updateById(locMast)) {
			throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
			}
			// 库存明细转移
			if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
			throw new CoolException(wrkMast.getWrkNo() + "任务库存明细转移失败！！！");
			}

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

			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			@@ -508,7 +529,7 @@
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			} else {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -524,7 +545,6 @@
			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// continue;
			}

			}
			@@ -536,7 +556,6 @@
			/**
			* 堆垛机站出库到出库站
			*/
			@Async
			public void crnStnToOutStn() {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			// 遍历堆垛机出库站
			@@ -642,7 +661,7 @@
			}
			}
			// 库位移转
			this.locToLoc(crn, crnProtocol);
			// this.locToLoc(crn, crnProtocol);
			}
			}
			}
			@@ -673,6 +692,15 @@
			// log.error("{}站点查询无待入库数据工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
			continue;
			}

			// 同库位组进行校验
			List<String> groupLocNo = Utils.getGroupLocNo(wrkMast.getLocNo());
			if (!Cools.isEmpty(groupLocNo)) {
			if (null != wrkMastMapper.selectPakoutWorkingByGroupLoc(groupLocNo)) {
			continue;
			}
			}

			if (wrkMast.getWrkSts() < 3) {
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
			&& staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
			@@ -719,42 +747,37 @@
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo());
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！
			switch (shallowLoc.getLocSts()) {
			case "P":
			case "R": {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			if (waitWrkMast.getWrkSts() < 17) {
			waitWrkMast.setIoPri(20D);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			//20220719 Add，如果浅库位状态为P/R，工作状态为14/15,说明浅库位已经空了，可以执行入库任务
			continue;
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			if (waitWrkMast.getWrkSts() < 17) {
			waitWrkMast.setIoPri(30D);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			//20220719 Add，如果浅库位状态为P/R，工作状态为14/15,说明浅库位已经空了，可以执行入库任务
			}
			break;
			}
			case "F":
			case "D":
			// 此标记避免多次执行移库任务
			if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())) {
			wrkMast.setUpdMk("Y");
			wrkMast.setIoPri(20D);
			wrkMastMapper.updateById(wrkMast);
			// 生成工作档、改变浅库位的源库/目标库库位状态、下发堆垛机命令（立马执行)
			moveLocForDeepLoc(slave, shallowLoc);
			}
			continue;
			}
			if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			// 此标记避免多次执行移库任务
			if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())) {
			wrkMast.setUpdMk("Y");
			wrkMast.setIoPri(20D);
			wrkMastMapper.updateById(wrkMast);
			// 生成工作档、改变浅库位的源库/目标库库位状态、下发堆垛机命令（立马执行)
			moveLocForDeepLoc(slave, shallowLoc);
			}
			continue;
			}
			if (shallowLoc.getLocSts().equals("Q")) {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null != waitWrkMast && waitWrkMast.getWrkSts() == 9) {
			continue;
			case "Q": {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null != waitWrkMast && waitWrkMast.getWrkSts() == 9) {
			continue;
			}
			break;
			}
			}
			}
			@@ -781,8 +804,9 @@
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}
			} else {
			@@ -797,11 +821,13 @@
			// 没有其他任务
			if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
			this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
			return true;
			}
			}
			// 小车搬走
			if (wrkMast.getWrkSts() == 3L) {
			this.carMoveOut(wrkMast, steNo, crnProtocol);
			return true;
			}
			// 没有小车
			} else {
			@@ -838,8 +864,9 @@
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}

			@@ -851,11 +878,13 @@
			Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			// 小车行走到待机位
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
			// 没有其他任务
			if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			} else {
			return true;
			}
			}
			// 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入 ===>> 7.吊车入库中
			@@ -892,8 +921,9 @@
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}
			}
			@@ -907,12 +937,14 @@
			if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
			return true;
			}
			}
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 3L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			return true;
			}
			}
			}
			@@ -925,7 +957,7 @@
			/**
			* 出库 ===>> 库位到堆垛机站
			*/
			public boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
			public synchronized boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			// 获取工作状态为11（生成出库ID）的出库工作档
			WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
			@@ -943,6 +975,24 @@
			log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			continue;
			}

			// 同库位组进行校验
			List<String> groupLocNo = Utils.getGroupLocNo(wrkMast.getSourceLocNo());
			if (!Cools.isEmpty(groupLocNo)) {
			if (null != wrkMastMapper.selectPakinWorkingByGroupLoc(groupLocNo)) {
			continue;
			}
			}

			// 判断是否有同库位组的出库任务，如果有，则暂停
			List<String> outsideLoc = Utils.getGroupOutsideLoc(wrkMast.getSourceLocNo());
			if (!Cools.isEmpty(outsideLoc)) {
			if (!Cools.isEmpty(wrkMastMapper.selectWorkingOfPakOutBySource(outsideLoc))) {
			// log.warn("{}工作档出库失败，原因：外层库位{}正在执行出库任务！", wrkMast.getWrkNo(), JSON.toJSONString(outsideLoc));
			continue;
			}
			}

			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			@@ -974,11 +1024,11 @@
			}

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

			// 判断是否为穿梭库
			if (!locMastService.isShuttle(wrkMast.getLocNo())) {
			if (!locMastService.isShuttle(wrkMast.getSourceLocNo())) {

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
			@@ -991,7 +1041,7 @@
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			if(waitWrkMast.getWrkSts() == 11) {
			waitWrkMast.setIoPri(20D);
			waitWrkMast.setIoPri(wrkMast.getIoPri() + 1);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			@@ -1039,8 +1089,9 @@
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			break;
			}

			} else {
			@@ -1074,8 +1125,9 @@
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			// 不是最外层库位，需要使用穿梭车搬运后，再堆垛机出库
			} else {
			@@ -1110,8 +1162,13 @@
			wrkMast.setSteNo(steNo);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			Integer outCrnNo = locMastService.getOutCrnNo(locMast);
			wrkMast.setCrnNo(outCrnNo);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			}
			@@ -1144,8 +1201,9 @@
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}

			@@ -1159,12 +1217,14 @@
			if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
			return true;
			}
			}
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 12L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			return true;
			}
			}
			}
			@@ -1178,6 +1238,7 @@
			/**
			* 库位移转
			*/
			@Deprecated
			public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
			// 获取工作档信息
			WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
			@@ -1255,11 +1316,12 @@
			// 获取堆垛机信息
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), true))
			&& steProtocol.getBay() == Utils.getBay(locNo)
			&& steProtocol.getLev() == Utils.getLev(locNo)) {
			return steProtocol.getSteNo().intValue();
			BasSte basSte = basSteService.selectById(ste.getId());
			if (Cools.isEmpty(steProtocol, basSte)) { continue; }
			if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(basSte.getRow(), true))
			&& basSte.getBay() == Utils.getBay(locNo)
			&& basSte.getLev() == Utils.getLev(locNo)) {
			return ste.getId();
			}
			}
			return null;
			@@ -1329,7 +1391,14 @@
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (!steProtocol.isIdle()) { continue; }
			if (steProtocol.getRow() == 1) { continue; }
			String locNo = wrkMast.getWrkSts() < 10 ? wrkMast.getLocNo() : wrkMast.getSourceLocNo();
			// 如果在同一个库位组
			if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), true))
			&& steProtocol.getBay().intValue() == Utils.getBay(locNo)
			&& steProtocol.getLev().intValue() == Utils.getLev(locNo)) {
			return steThread;
			}
			LocMast locMast = locMastService.selectById(locNo);
			int lev = locMast.getLev1();
			int bay = locMast.getBay1();
			@@ -1349,8 +1418,7 @@
			}

			/**
			* 让小车从远点 ====>> 待机
			* 等待堆垛机搬运
			* 让小车行走至待机位
			*/
			public void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
			// 获取穿梭车信息
			@@ -1359,24 +1427,35 @@
			if (steProtocol == null) { return; }
			if (steProtocol.isIdle()) {

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

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).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 {
			// 如果处于待机位
			if (steProtocol.locaType.equals(SteLocaType.A_WAITING) \|\| steProtocol.locaType.equals(SteLocaType.B_WAITING)) {
			// 修改工作档状态绑定穿梭车
			wrkMast.setWrkSts(3L);
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findWaiting(steProtocol.getRow().intValue())); // 任务模式: 行走至待机位

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).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 {
			// 修改工作档状态绑定穿梭车
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			@@ -1459,7 +1538,7 @@
			if (steProtocol == null) { return; }
			if (steProtocol.isIdle()) {
			// 堆垛机空闲
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() == 0) {
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) && crnProtocol.getTaskNo() == 0) {
			LocMast locMast;
			// 入库搬
			if (wrkMast.getWrkSts() <= 10) {
			@@ -1551,7 +1630,7 @@
			// 穿梭车空闲
			if (steProtocol.isIdle()) {
			// 堆垛机空闲
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() == 0) {
			if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) && crnProtocol.getTaskNo() == 0) {

			BasSte basSte = basSteService.selectById(steNo);
			if (basSte == null) {
			@@ -1602,7 +1681,6 @@
			/**
			* 执行对工作档的完成操作
			*/
			@Async
			@Transactional
			public void storeFinished() {
			for (CrnSlave crn : slaveProperties.getCrn()) {
			@@ -1663,6 +1741,34 @@
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 42) {
			// 42.吊车搬运 ===>> 43.小车到达
			wrkCharge.setWrkSts(43L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改复位任务状态 42.吊车搬运 ===>> 43.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 46) {
			// 46.放至待机位 ===>> 47.复位成功
			wrkCharge.setWrkSts(47L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改复位任务状态 46.放至待机位 ===>> 47.复位成功失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			}
			@@ -1817,6 +1923,9 @@
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			Integer outCrnNo = locMastService.getOutCrnNo(locMast);
			wrkMast.setCrnNo(outCrnNo);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			@@ -1906,6 +2015,14 @@
			wrkCharge.setWrkSts(37L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			} else if (wrkCharge.getWrkSts() == 44) {
			// 44.小车走行 ===>> 45.小车待搬
			wrkCharge.setWrkSts(45L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 44.小车走行 ===>> 45.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2229,7 +2346,6 @@
			/**
			* 空栈板初始化入库,叉车入库站放货
			*/
			@Async
			public void storeEmptyPlt(){
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历空板入库口
			@@ -2274,7 +2390,7 @@
			param.setBarcode(barcode);
			}
			param.setSourceStaNo(emptyInSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			// param.setLocType1(locTypeDto.getLocType1());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			@@ -2318,7 +2434,6 @@
			/**
			* 出库 ===>> 工作档信息写入led显示器
			*/
			@Async
			public void ledExecute() {
			for (LedSlave led : slaveProperties.getLed()) {
			// 获取输送线plc线程
			@@ -2419,7 +2534,6 @@
			/**
			* 其他 ===>> LED显示器复位，显示默认信息
			*/
			@Async
			public void ledReset() {
			for (LedSlave led : slaveProperties.getLed()) {
			// 获取输送线plc线程
			@@ -2451,6 +2565,12 @@
			*/
			@SuppressWarnings("serial")
			public synchronized void loopSteCharge() {
			if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) {
			return;
			}
			if (null != wrkChargeService.selectWorking(null, WrkChargeType.charge)) {
			return;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			for (SteSlave ste : slaveProperties.getSte()) {
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
			@@ -2473,7 +2593,7 @@
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
			continue;
			}
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null);
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);

			if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
			// 寻找空闲充电桩
			@@ -2481,23 +2601,29 @@
			do {
			String locNo;
			if (!devpThread.charge0) {
			locNo = SteChargeType.FIRST.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null) {
			steCharge = SteChargeType.FIRST;
			SteChargeType first = SteChargeType.FIRST;
			locNo = first.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null
			&& wrkChargeService.selectWorkingOfCharge(first.ssbm) == null) {
			steCharge = first;
			break;
			}
			}
			if (!devpThread.charge1) {
			locNo = SteChargeType.SECOND.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null) {
			steCharge = SteChargeType.SECOND;
			SteChargeType second = SteChargeType.SECOND;
			locNo = second.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null
			&& wrkChargeService.selectWorkingOfCharge(second.ssbm) == null) {
			steCharge = second;
			break;
			}
			}
			if (!devpThread.charge2) {
			locNo = SteChargeType.THIRD.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null) {
			steCharge = SteChargeType.THIRD;
			SteChargeType third = SteChargeType.THIRD;
			locNo = third.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null
			&& wrkChargeService.selectWorkingOfCharge(third.ssbm) == null) {
			steCharge = third;
			break;
			}
			}
			@@ -2511,15 +2637,51 @@
			String chargeLocNo = steCharge.locNo;
			wrkCharge = new WrkCharge();
			wrkCharge.setSteNo(ste.getId());
			wrkCharge.setCharge(steCharge.ssbm);
			wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
			wrkCharge.setWrkSts(21L); // 21.准备充电
			wrkCharge.setCrnNo(2); // 固定2号堆垛机
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setLocNo(chargeLocNo);
			wrkCharge.setMemo("charge");
			wrkCharge.setAppeTime(new Date());
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
			continue;
			}

			// 小车处于通道
			List<String> channel = slaveProperties.getChannel();
			for (String channelLocNo : channel) {
			if (steProtocol.getRow().intValue() == Utils.getRow(channelLocNo)
			&& steProtocol.getBay().intValue() == Utils.getBay(channelLocNo)
			&& steProtocol.getLev().intValue() == Utils.getLev(channelLocNo)) {
			Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
			if (null != otherSte) {
			log.warn("{}号小车充电阻断，原因：通道存在{}号穿梭车！", wrkCharge.getSteNo(), otherSte);
			} else {
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN); // 去右端

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
			steCommand.setBay(steProtocol.getBay());
			steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 21.准备充电 ===> 25.小车走行
			wrkCharge.setWrkSts(25L);
			Date now = new Date();
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 21.准备充电 ===> 25.小车走行失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			}
			}

			// 处于充电库位组
			@@ -2536,154 +2698,199 @@
			this.letCarBeWaiting(wrkCharge, ste.getId());
			}

			} else {
			// filter
			if (wrkCharge == null \|\| (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1)) {
			continue;
			}
			break;
			}
			} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("loopSteCharge fail", e);
			}
			}
			}

			// 22.小车待搬
			if (wrkCharge.getWrkSts() == 22) {
			/**
			* 执行小车充电任务
			*/
			public synchronized void executeSteCharge() {
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
			if (null == wrkCharge) { return; }
			Integer steNo = wrkCharge.getSteNo();
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(steNo);
			if (Cools.isEmpty(steProtocol, basSte)) { return; }
			if (steProtocol.getMode() == 0
			\|\| !steProtocol.statusType.equals(SteStatusType.IDLE)
			\|\| basSte.getPakMk().equals("Y")
			\|\| basSte.getAutoCharge().equals("N")
			// \|\| steProtocol.getChargeStatus() == 1
			) {
			return;
			}
			if (!steProtocol.isEnable()) {
			return;
			}
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
			wrkCharge.setWrkSts(30L);
			wrkChargeMapper.updateById(wrkCharge);
			return;
			}
			try {
			// filter
			if (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1) {
			return;
			}

			// 搬小车至小车走向通道
			List<String> channel = slaveProperties.getChannel();
			for (String channelLocNo : channel) {
			Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
			if (null != otherSte) {
			log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
			} else {
			LocMast channelLoc = locMastService.selectById(channelLocNo);
			// 22.小车待搬
			if (wrkCharge.getWrkSts() == 22) {

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
			// 修改工作档状态 22.小车待搬 => 23.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(23L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			break;
			}
			// 入出库任务优先
			if (null != wrkMastMapper.selectWorkingByCrn(wrkCharge.getCrnNo())) {
			return;
			}

			}
			}
			// 搬小车至小车走向通道
			List<String> channel = slaveProperties.getChannel();
			for (String channelLocNo : channel) {
			Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
			if (null != otherSte) {
			log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
			} else {
			LocMast channelLoc = locMastService.selectById(channelLocNo);

			} else if (wrkCharge.getWrkSts() == 24L) {
			// 小车行驶通道
			if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
			if (steProtocol.getChargeStatus() == 1) { continue; }
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN); // 去右端

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
			steCommand.setBay(steProtocol.getBay());
			steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 24.小车到达 ===> 25.小车走行
			wrkCharge.setWrkSts(25L);
			Date now = new Date();
			wrkCharge.setCrnEndTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 24.小车到达 ===> 25.小车走行失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 26) {
			// 固定堆垛机
			int crnNo = 1;
			// 充电位
			LocMast chargeLoc = locMastService.selectById(wrkCharge.getLocNo());

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(crnNo); // 堆垛机编号
			crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
			crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(chargeLoc.getRow1(), chargeLoc.getBay1(), chargeLoc.getLev1());
			// 修改工作档状态 26.等待充电 => 27.放至充电位
			steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
			// 修改工作档状态 22.小车待搬 => 23.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(27L);
			wrkCharge.setWrkSts(23L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 26.等待充电 => 27.放至充电位失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			break;
			}
			} else if (wrkCharge.getWrkSts() == 28L) {
			// 穿梭车下发充电任务
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 28.充电就绪 ===>> 29.开始充电
			wrkCharge.setWrkSts(29L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}

			}
			}

			} else if (wrkCharge.getWrkSts() == 24L) {
			// 小车行驶通道
			if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
			if (steProtocol.getChargeStatus() == 1) { return; }
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN); // 去右端

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
			steCommand.setBay(steProtocol.getBay());
			steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 24.小车到达 ===> 25.小车走行
			wrkCharge.setWrkSts(25L);
			Date now = new Date();
			wrkCharge.setCrnEndTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 24.小车到达 ===> 25.小车走行失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} catch (Exception e) {
			log.error("fail", e);
			} else if (wrkCharge.getWrkSts() == 26) {
			// 固定堆垛机
			int crnNo = 1;
			// 入出库任务优先
			if (null != wrkMastMapper.selectWorkingByCrn(crnNo)) {
			return;
			}

			// 充电位
			LocMast chargeLoc = locMastService.selectById(wrkCharge.getLocNo());

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { return; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(crnNo); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(chargeLoc.getRow1(), chargeLoc.getBay1(), chargeLoc.getLev1());
			// 修改工作档状态 26.等待充电 => 27.放至充电位
			Date now = new Date();
			wrkCharge.setWrkSts(27L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 26.等待充电 => 27.放至充电位失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 28L) {
			// 穿梭车下发充电任务
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 28.充电就绪 ===>> 29.开始充电
			wrkCharge.setWrkSts(29L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} catch (Exception e) {
			log.error("executeSteCharge fail", e);
			}
			}

			/**
			* 小车从充电桩至待机库位
			* 轮询充电桩是否有空闲小车
			*/
			public synchronized void steFromChargeToIdleLoc() {
			public synchronized void queryChargeLocOfComplete() {
			// 与充电任务不同步进行
			if (null != wrkChargeService.selectWorking(null)) { return; }
			if (null != wrkChargeService.selectWorking(null, WrkChargeType.charge)) { return; }
			if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) { return; }
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			// 检索充电桩
			for (SteChargeType value : SteChargeType.values()) {
			@@ -2695,42 +2902,196 @@
			if (Cools.isEmpty(steProtocol, basSte)) {
			continue;
			}
			// 1号充电桩
			if (value.equals(SteChargeType.FIRST) && devpThread.charge0) {
			if (steProtocol.getCharge() < 99) {
			continue;
			}
			// 2号充电桩
			if (value.equals(SteChargeType.SECOND) && devpThread.charge1) {
			if (steProtocol.getMode() == 0) {
			continue;
			}
			// 3号充电桩
			if (value.equals(SteChargeType.THIRD) && devpThread.charge2) {
			if (!steProtocol.getStatusType().equals(SteStatusType.IDLE)) {
			continue;
			}
			// 小车是否处于充电状态
			if (steProtocol.getChargeStatus() == 1) {
			continue;
			}
			// // 1号充电桩
			// if (value.equals(SteChargeType.FIRST) && devpThread.charge0) {
			// continue;
			// }
			// // 2号充电桩
			// if (value.equals(SteChargeType.SECOND) && devpThread.charge1) {
			// continue;
			// }
			// // 3号充电桩
			// if (value.equals(SteChargeType.THIRD) && devpThread.charge2) {
			// continue;
			// }
			// // 小车是否处于充电状态
			// if (steProtocol.getChargeStatus() == 1) {
			// continue;
			// }
			// case 1 : 自动充电开馈电 ×
			// case 2 : 自动充电开满电 ✔
			// case 3 : 自动充电关馈电 ✔
			// case 4 : 自动充电关满电 ✔
			if (basSte.getAutoCharge().equals("Y")
			&& steProtocol.getCharge() < Float.parseFloat(basSte.getChargeLine())) {
			&& steProtocol.getCharge() < Float.parseFloat(basSte.getChargeLine())) {
			continue;
			}
			// 开始穿梭车复位任务
			WrkCharge wrkCharge = new WrkCharge();
			wrkCharge.setSteNo(steNo);
			wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
			wrkCharge.setWrkSts(41L); // 41.小车准备复位
			wrkCharge.setCrnNo(2); // 固定2号堆垛机
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setLocNo(basSte.getIdleLoc());
			wrkCharge.setMemo("reset");
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("保存{}号穿梭车复位任务失败!!!", steNo);
			continue;

			WrkCharge wrkCharge = wrkChargeService.selectWorking(steNo, WrkChargeType.reset);

			if (wrkCharge == null) {
			// 开始穿梭车复位任务
			wrkCharge = new WrkCharge();
			wrkCharge.setSteNo(steNo);
			wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
			wrkCharge.setWrkSts(41L); // 41.小车准备复位
			wrkCharge.setCrnNo(2); // 固定2号堆垛机
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setSourceLocNo(value.locNo);
			wrkCharge.setLocNo(basSte.getIdleLoc());
			wrkCharge.setMemo("reset");
			wrkCharge.setAppeTime(new Date());
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("保存{}号穿梭车复位任务失败!!!", steNo);
			} else {
			break;
			}
			}
			}
			}
			}

			/**
			* 小车从充电桩至待机库位
			*/
			public synchronized void steFromChargeToIdleLoc() {
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.reset);
			if (wrkCharge == null) { return; }
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(wrkCharge.getSteNo());
			if (Cools.isEmpty(steProtocol, basSte)) {
			return;
			}
			// 搬运至固定通道
			if (wrkCharge.getWrkSts() == 41L) {
			// 搬小车至小车走向通道
			List<String> channel = slaveProperties.getChannel();
			for (String channelLocNo : channel) {
			Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
			if (null != otherSte) {
			log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
			} else {
			// 固定堆垛机
			int crnNo = 1;
			if (null != wrkMastMapper.selectWorkingByCrn(crnNo)) {
			return;
			}

			LocMast channelLoc = locMastService.selectById(channelLocNo);

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(crnNo); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(steProtocol.getRow()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), false).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), false), channelLoc.getBay1(), channelLoc.getLev1());
			// 修改工作档状态 41.小车准备复位 => 42.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(42L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改复位任务状态 41.小车准备复位 => 42.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			break;
			}

			}
			}
			} else if (wrkCharge.getWrkSts() == 43L) {
			// 小车行驶通道
			if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.BACK_ORIGIN); // 去左端

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());
			steCommand.setBay(steProtocol.getBay());
			steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 43.小车到达 ===> 44.小车走行
			wrkCharge.setWrkSts(44L);
			Date now = new Date();
			wrkCharge.setCrnEndTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改复位任务状态 43.小车到达 ===> 44.小车走行失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 45L) {
			if (null != wrkMastMapper.selectWorkingByCrn(wrkCharge.getCrnNo())) {
			return;
			}

			LocMast idleLoc = locMastService.selectById(basSte.getIdleLoc());

			Integer otherSte = existOtherSte(idleLoc.getLocNo(), wrkCharge.getSteNo());
			if (null != otherSte) {
			log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), idleLoc.getLocNo(), otherSte);
			} else {
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { return; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(idleLoc.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(idleLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(idleLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(idleLoc.getLocNo(), true), idleLoc.getBay1(), idleLoc.getLev1());
			// 修改工作档状态 45.小车待搬 => 46.放至待机位
			Date now = new Date();
			wrkCharge.setWrkSts(46L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 45.小车待搬 => 46.放至待机位失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}

			}
			@@ -2759,7 +3120,6 @@
			}
			}
			}


			if (null != loc) {
			break;