zy-wcs.git - Gitblit

			@@ -3,43 +3,35 @@
			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			import com.baomidou.mybatisplus.mapper.Wrapper;
			import com.core.common.Cools;
			import com.core.common.SpringUtils;
			import com.core.exception.CoolException;
			import com.zy.asrs.entity.*;
			import com.zy.asrs.mapper.BasCrnErrorMapper;
			import com.zy.asrs.mapper.WrkChargeMapper;
			import com.zy.asrs.mapper.WrkMastMapper;
			import com.zy.asrs.mapper.*;
			import com.zy.asrs.service.*;
			import com.zy.asrs.utils.Utils;
			import com.zy.common.model.LocTypeDto;
			import com.zy.common.model.MatDto;
			import com.zy.common.model.SearchLocParam;
			import com.zy.common.model.StartupDto;
			import com.zy.common.model.*;
			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;
			import com.zy.common.service.erp.ErpService;
			import com.zy.common.utils.*;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.News;
			import com.zy.core.cache.MessageQueue;
			import com.zy.core.cache.SlaveConnection;
			import com.zy.core.enums.*;
			import com.zy.core.model.*;
			import com.zy.core.model.command.CrnCommand;
			import com.zy.core.model.command.LedCommand;
			import com.zy.core.model.command.SteCommand;
			import com.zy.core.model.command.*;
			import com.zy.core.model.protocol.CrnProtocol;
			import com.zy.core.model.protocol.ShuttleProtocol;
			import com.zy.core.model.protocol.StaProtocol;
			import com.zy.core.model.protocol.SteProtocol;
			import com.zy.core.properties.SlaveProperties;
			import com.zy.core.thread.BarcodeThread;
			import com.zy.core.thread.LedThread;
			import com.zy.core.thread.SiemensDevpThread;
			import com.zy.core.thread.SteThread;
			import com.zy.core.thread.*;
			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;
			@@ -90,12 +82,19 @@
			private CommonService commonService;
			@Autowired
			private WrkChargeMapper wrkChargeMapper;
			@Autowired
			private ErpService erpService;
			@Autowired
			private OrderMapper orderMapper;
			@Autowired
			private OrderDetlMapper orderDetlMapper;
			@Autowired
			private RedisUtil redisUtil;

			/**
			* 组托
			* 入库站，根据条码扫描生成入库工作档，工作状态 2
			*/
			@Async
			public void generateStoreWrkFile() {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			@@ -110,6 +109,46 @@
			staProtocol = staProtocol.clone();
			}
			Short workNo = staProtocol.getWorkNo();
			// 尺寸检测异常
			boolean back = false;
			String errMsg = "异常：";
			if (staProtocol.isFrontErr()) {
			errMsg = errMsg+"前超限；";
			back = true;
			}
			if (staProtocol.isBackErr()) {
			errMsg = errMsg+"后超限";
			back = true;
			}
			if (staProtocol.isHighErr()) {
			errMsg = errMsg+"高超限";
			back = true;
			}
			if (staProtocol.isLeftErr()) {
			errMsg = errMsg+"左超限";
			back = true;
			}
			if (staProtocol.isRightErr()) {
			errMsg = errMsg+"右超限";
			back = true;
			}
			if (staProtocol.isWeightErr()) {
			errMsg = errMsg+"超重";
			back = true;
			}
			if (staProtocol.isBarcodeErr()) {
			errMsg = errMsg+"扫码失败";
			back = true;
			}
			// 退回
			if (back) {
			// led 异常显示
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
			}
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing() && staProtocol.isLoading()
			&& staProtocol.isInEnable()
			@@ -123,9 +162,9 @@
			}
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode)) {
			// log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)) {
			staProtocol.setWorkNo((short) 9995);
			// News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(barcode)\|\| "00000000".equals(barcode)) {
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -139,7 +178,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));
			@@ -153,12 +192,17 @@
			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) {
			// News.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			// continue;
			// }

			try {
			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			@@ -166,7 +210,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")
			@@ -195,9 +239,9 @@
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			} else if (code == 700) {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -221,7 +265,7 @@
			* wms入库
			* 入库站，根据条码扫描生成入库工作档，工作状态 1 ==>> 2
			*/
			@Async
			@Deprecated
			public void generateStoreWrkFile0() {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			@@ -241,6 +285,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) {
			News.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; }
			@@ -257,10 +350,10 @@
			wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			News.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			} else {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}
			}
			}
			@@ -268,63 +361,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()) {
			@@ -341,65 +380,62 @@
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			// 0 - 9990 或者 9996
			&& ((staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) \|\| staProtocol.getWorkNo() == 9996)
			&& staProtocol.getStaNo().equals(staProtocol.getWorkNo())
			&& (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)) {
			// News.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) {
			// News.error("{}条码错误，暂无拣料任务！", barcode);
			// }
			// }
			if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
			\|\| Cools.isEmpty(wrkMast.getStaNo()) \|\| Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
			continue;
			@@ -412,7 +448,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")
			@@ -432,7 +468,7 @@
			// .eq("crn_no", dto.getCrnNo()); // 堆垛机号
			// StaDesc staDesc = staDescService.selectOne(wrapper);
			// if (Cools.isEmpty(staDesc)) {
			// log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			// News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
			// continue;
			// }
			// // 堆垛机站点(目标站)
			@@ -447,6 +483,7 @@
			throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
			}

			String sourceLocNo = wrkMast.getSourceLocNo().trim();
			// 更新工作档数据状态
			wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
			wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
			@@ -462,27 +499,6 @@
			if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
			throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
			}
			// 修改源库位状态 O.空库位
			LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			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(), wrkMast.getSourceLocNo())) {
			throw new CoolException(wrkMast.getWrkNo() + "任务库存明细转移失败！！！");
			}

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

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

			} else if (code == 500){
			@@ -500,9 +516,9 @@
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			} else {
			staProtocol.setWorkNo((short) 9995);
			staProtocol.setWorkNo((short) 32002);
			staProtocol.setStaNo(pickSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			@@ -518,7 +534,6 @@
			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// continue;
			}

			}
			@@ -530,7 +545,6 @@
			/**
			* 堆垛机站出库到出库站
			*/
			@Async
			public void crnStnToOutStn() {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			// 遍历堆垛机出库站
			@@ -581,7 +595,7 @@
			// 复位堆垛机
			crnThread.setResetFlag(true);
			} else {
			log.error("更新工作档的工作状态为 17.出库完成失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			News.error("更新工作档的工作状态为 17.出库完成失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}

			}
			@@ -589,6 +603,51 @@
			}
			}
			}
			}

			/**
			* 入出库 ===>> 四向穿梭车入出库作业下发
			*/
			public synchronized void shuttleIoExecute() {
			for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			//获取四向穿梭车信息
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
			ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
			if (shuttleProtocol == null) {
			continue;
			}

			// 只有当四向穿梭车空闲并且无任务时才继续执行
			if (shuttleProtocol.getBusyStatusType() == ShuttleStatusType.IDLE && shuttleProtocol.getTaskNo() == 0) {
			//入出库逻辑
			for (WrkMast wrkSts : wrkMastMapper.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 2))) {
			//分配任务号
			shuttleProtocol.setTaskNo(wrkSts.getWrkNo().shortValue());
			//分配源库位
			shuttleProtocol.setSourceLocNo(wrkSts.getSourceLocNo());
			//分配目标库位
			shuttleProtocol.setLocNo(wrkSts.getLocNo());


			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			//四向穿梭车号
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
			//任务号
			assignCommand.setTaskNo(wrkSts.getWrkNo().shortValue());
			//入出库模式
			assignCommand.setTaskMode(0);
			//源库位
			assignCommand.setSourceLocNo(wrkSts.getSourceLocNo());
			//目标库位
			assignCommand.setDistLocNo(wrkSts.getLocNo());

			//下发任务
			MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
			}

			}
			}

			}

			/**
			@@ -602,7 +661,7 @@
			if (crnProtocol == null) { continue; }
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			News.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}
			// 只有当堆垛机空闲并且无任务时才继续执行
			@@ -636,9 +695,9 @@
			}
			}
			// 库位移转
			this.locToLoc(crn, crnProtocol);
			// 演示任务
			this.steMoveDemo(crn, crnProtocol);
			// this.locToLoc(crn, crnProtocol);
			// 演示
			// this.steMoveDemo(crn, crnProtocol);
			}
			}
			}
			@@ -660,15 +719,24 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}
			// 获取工作状态为 2,3,4,5,6 的入库工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep23456(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
			if(null == wrkMast) {
			// log.error("{}站点查询无待入库数据工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
			// News.error("{}站点查询无待入库数据工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
			continue;
			}

			// 同库位组进行校验
			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")) {
			@@ -681,26 +749,73 @@
			// 获取库位信息
			LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
			if (locMast == null) {
			log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			News.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			continue;
			}
			if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
			log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			News.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			continue;
			}

			// 过滤
			List<LocMast> locMasts = null;
			boolean sign=false;
			if (locMast.getRow1()>=5){
			locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
			.eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
			for (LocMast locMast1:locMasts){
			if (locMast1.getRow1()>locMast.getRow1()){
			if (!locMast1.getLocSts().equals("F") && !locMast1.getLocSts().equals("D")){
			if (!locMast1.getLocSts().equals("X")){
			sign=true;
			break;
			}
			}
			}else if (locMast1.getRow1()<locMast.getRow1()){
			if (locMast1.getLocSts().equals("F") \|\| locMast1.getLocSts().equals("D")){
			News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
			sign=true;
			break;
			}
			}
			}
			}else {
			locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
			.eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
			for (LocMast locMast1:locMasts){
			if (locMast1.getRow1()>locMast.getRow1()){
			if (locMast1.getLocSts().equals("F") \|\| locMast1.getLocSts().equals("D")){
			News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
			sign=true;
			break;
			}
			}else if (locMast1.getRow1()<locMast.getRow1()){
			if (!locMast1.getLocSts().equals("F") && !locMast1.getLocSts().equals("D")){
			if (!locMast1.getLocSts().equals("X")){
			sign=true;
			break;
			}
			}
			}
			}
			}
			if (sign){
			continue;
			}

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

			// 置顶任务
			wrkMast.setIoPri((double) 9999);
			if (wrkMast.getIoPri()<8000){
			wrkMast.setIoPri(wrkMast.getIoPri()+9000d);
			}
			wrkMastMapper.updateById(wrkMast);

			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
			// 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
			Integer steNo = this.hasCar(wrkMast.getLocNo());
			// 有小车
			@@ -710,13 +825,15 @@
			// 没有其他任务
			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 {

			// 当前入库库位组没有小车堆垛机则去站点取货入库
			@@ -742,7 +859,7 @@
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 7.吊车入库中
			Date now = new Date();
			@@ -750,9 +867,10 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			News.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}

			@@ -764,11 +882,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.吊车入库中
			@@ -792,11 +912,11 @@
			crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排
			crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 3.小车待搬 ===>> 7.吊车入库中
			Date now = new Date();
			@@ -804,9 +924,10 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}
			}
			@@ -820,16 +941,17 @@
			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;
			}
			}
			}

			}
			return false;
			}
			@@ -837,7 +959,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());
			@@ -846,15 +968,63 @@
			}
			// 工作档状态判断
			if (wrkMast.getIoType() < 100 \|\| wrkMast.getSourceStaNo() == null){
			log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			News.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			continue;
			}
			// 获取源库位信息
			LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
			if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
			log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			continue;
			}
			List<LocMast> locMasts = null;
			boolean sign=false;
			if (sourceSta.getRow1()>=5){
			locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
			.eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
			for (LocMast locMast1:locMasts){
			if (locMast1.getRow1()<sourceSta.getRow1()){
			if (!locMast1.getLocSts().equals("O")){
			News.error("当前工作档源库位所在排前边存在货物！", wrkMast.getWrkNo());
			sign=true;
			break;
			}
			}
			}
			}else {
			locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
			.eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
			for (LocMast locMast1:locMasts){
			if (locMast1.getRow1()>sourceSta.getRow1()){
			if (!locMast1.getLocSts().equals("O")){
			News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
			sign=true;
			break;
			}
			}
			}
			}
			if (sign){
			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))) {
			// News.warn("{}工作档出库失败，原因：外层库位{}正在执行出库任务！", wrkMast.getWrkNo(), JSON.toJSONString(outsideLoc));
			continue;
			}
			}

			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			@@ -866,7 +1036,7 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}
			// 判断堆垛机出库站状态
			@@ -881,16 +1051,18 @@

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

			// 置顶任务
			wrkMast.setIoPri((double) 9999);
			if (wrkMast.getIoPri()<8000){
			wrkMast.setIoPri(wrkMast.getIoPri()+8999d);
			}
			wrkMastMapper.updateById(wrkMast);

			// 最外层库位，直接堆垛机出库
			if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
			if (locMastService.isOutMost(wrkMast.getSourceLocNo(), false)) {
			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			@@ -909,7 +1081,7 @@
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 16.吊车出库中
			Date now = new Date();
			@@ -917,11 +1089,12 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			// 不是最外层库位，需要使用穿梭车搬运后，再堆垛机出库
			// 不是最外层库位，需要使用穿梭车搬运后，再堆垛机出库
			} else {
			// 当前组库位是否有穿梭车
			Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
			@@ -941,12 +1114,12 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 去近点等待堆垛机叉取

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).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));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 14.小车搬出库
			Date now = new Date();
			@@ -954,8 +1127,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());
			News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			}
			@@ -972,14 +1150,14 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(sourceSta.getRow1()).shortValue()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(sourceSta.getRow1(), false).shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 15.等待吊车 => 16.吊车出库中
			Date now = new Date();
			@@ -987,13 +1165,14 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			return true;
			}
			}

			// 没有小车
			// 没有小车
			} else {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 寻找最近的小车
			@@ -1003,16 +1182,17 @@
			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;
			}
			}
			}

			}
			}
			return false;
			@@ -1021,6 +1201,7 @@
			/**
			* 库位移转
			*/
			@Deprecated
			public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
			// 获取工作档信息
			WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
			@@ -1030,7 +1211,7 @@
			// 获取源库位信息
			LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceLoc) {
			log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			@@ -1040,7 +1221,7 @@
			// 获取目标库位信息
			LocMast loc = locMastService.selectById(wrkMast.getLocNo());
			if (null == loc) {
			log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}
			// 获取堆垛机信息并判断是否可入出
			@@ -1063,251 +1244,31 @@
			wrkMast.setIoPri((double) 9999);
			wrkMastMapper.updateById(wrkMast);

			// 源库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			// todo:luxiaotao 判断目标库位是否存在小车，如果存在，则搬走小车

			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(loc.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 16.吊车出库中
			Date now = new Date();
			wrkMast.setWrkSts(16L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("【库位移转】修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else {
			Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			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);
			}
			}
			}

			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(loc.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(loc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(loc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {

			// 当前组库位是否有穿梭车
			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 {

			// 把货搬到临时存放货位 todo:luxiaotao


			// 小车行走到堆垛机待搬移点
			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);
			}
			// 修改工作档状态 11.生成出库ID => 16.吊车出库中
			Date now = new Date();
			wrkMast.setWrkSts(16L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("【库位移转】修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}

			}

			/**
			@@ -1318,12 +1279,46 @@
			// 获取堆垛机信息
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && 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;
			}

			/**
			* 当前库位组是否存在其他小车
			*/
			public Integer existOtherSte(String locNo, Integer steNo) {
			Integer otherSteNo = null;
			for (SteSlave ste : slaveProperties.getSte()) {
			if (ste.getId().equals(steNo)) { continue; }
			// 获取堆垛机信息
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (steProtocol.isEnable()) {
			BasSte basSte = basSteService.selectById(ste.getId());
			if (basSte != null) {
			if ((Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(basSte.getRow(), true))
			&& basSte.getBay() == Utils.getBay(locNo)
			&& basSte.getLev() == Utils.getLev(locNo))
			\|\|
			(Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), true))
			&& steProtocol.getBay() == Utils.getBay(locNo)
			&& steProtocol.getLev() == Utils.getLev(locNo))
			) {
			otherSteNo = ste.getId();
			break;
			}
			}
			}
			}
			return otherSteNo;
			}

			/**
			@@ -1336,7 +1331,9 @@
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (steProtocol.isIdle()) {
			if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
			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();
			}
			}
			@@ -1348,22 +1345,71 @@
			* 查找当前库位最适合的穿梭车来作业
			*/
			public SteThread queryIdleCar(WrkMast wrkMast) {
			Integer crnNo = wrkMast.getCrnNo();
			BasSte basSte = basSteService.findByCrnNo(crnNo);
			// 获取穿梭车信息
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol != null) {
			if (steProtocol.isIdle()) {
			List<BasSte> basStes = basSteService.selectList(new EntityWrapper<>());
			int val = 0;
			SteThread result = null;
			for (BasSte basSte : basStes) {
			// 获取穿梭车信息
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
			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();
			int levAbs = Math.abs(lev - steProtocol.getLev());
			int bayAbs = Math.abs(bay - steProtocol.getBay());
			if (val == 0) {
			val = levAbs + bayAbs;
			result = steThread;
			} else {
			if ((levAbs + bayAbs) < val) {
			val = levAbs + bayAbs;
			result = steThread;
			}
			}
			}
			return null;
			return result;
			}

			public SteThread queryIdleCar(CrnProtocol crnProtocol) {
			List<BasSte> basStes = basSteService.selectList(new EntityWrapper<>());
			int val = 0;
			SteThread result = null;
			for (BasSte basSte : basStes) {
			// 获取穿梭车信息
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (!steProtocol.isIdle()) { continue; }
			if (steProtocol.getRow() == 1) { continue;}
			int lev = crnProtocol.getLevel();
			int bay = crnProtocol.getBay();
			int levAbs = Math.abs(lev - steProtocol.getLev());
			int bayAbs = Math.abs(bay - steProtocol.getBay());
			if (val == 0) {
			val = levAbs + bayAbs;
			result = steThread;
			} else {
			if ((levAbs + bayAbs) < val) {
			val = levAbs + bayAbs;
			result = steThread;
			}
			}
			}
			return result;
			}

			/**
			* 让小车从远点 ====>> 待机
			* 等待堆垛机搬运
			* 让小车行走至待机位
			*/
			public void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
			// 获取穿梭车信息
			@@ -1372,24 +1418,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()).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());
			News.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))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态绑定穿梭车
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			@@ -1402,7 +1459,7 @@
			if (steProtocol == null) { return; }

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

			@@ -1410,20 +1467,20 @@
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOriginByLoc(steProtocol.getRow())); // 任务模式: 去近点等待堆垛机叉取
			steCommand.setTaskMode(SteTaskModeType.findOriginByLoc(steProtocol.getRow().intValue())); // 任务模式: 去近点等待堆垛机叉取

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			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));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态绑定穿梭车
			wrkCharge.setSteNo(steNo);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			@@ -1445,18 +1502,18 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOriginByLoc(steProtocol)); // 任务模式: 去近点等待堆垛机叉取

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			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));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态绑定穿梭车
			wrkMast.setSteNo(steNo);
			wrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1479,18 +1536,18 @@
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOriginByLoc(steProtocol)); // 任务模式: 去近点等待堆垛机叉取

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			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));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态绑定穿梭车
			wrkCharge.setSteNo(steNo);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改工作档状态绑定穿梭车失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			@@ -1506,10 +1563,18 @@
			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) {

			// 判断被移库位是否存在其他小车
			Integer otherSte = existOtherSte(wrkMast.getLocNo(), steNo);
			if (otherSte != null) {
			News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", steNo, wrkMast.getLocNo(), otherSte);
			return;
			}

			locMast = locMastService.selectById(wrkMast.getLocNo());
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			@@ -1517,28 +1582,35 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 3.小车待搬 => 4.迁入小车
			Date now = new Date();
			wrkMast.setWrkSts(4L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			// 出库搬
			} else {
			// 判断被移库位是否存在其他小车
			Integer otherSte = existOtherSte(wrkMast.getSourceLocNo(), steNo);
			if (otherSte != null) {
			News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", steNo, wrkMast.getSourceLocNo(), otherSte);
			return;
			}

			locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			@@ -1546,24 +1618,24 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 12.小车待搬 => 13.迁入小车
			Date now = new Date();
			wrkMast.setWrkSts(13L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 12.小车待搬 => 13.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 12.小车待搬 => 13.迁入小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1583,14 +1655,22 @@
			// 穿梭车空闲
			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) {
			log.error("{}号穿梭车在数据库不存在！！！", steNo);
			News.error("{}号穿梭车在数据库不存在！！！", steNo);
			return;
			}

			String idleLocNo = basSte.getIdleLoc();

			// 判断被移库位是否存在其他小车
			Integer otherSte = existOtherSte(idleLocNo, steNo);
			if (otherSte != null) {
			News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", steNo, idleLocNo, otherSte);
			return;
			}

			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			@@ -1598,24 +1678,24 @@
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(idleLocNo).shortValue()); // 目标库位排
			crnCommand.setDestinationPosX(Utils.getGroupRow(idleLocNo, true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY((short) Utils.getBay(idleLocNo)); // 目标库位列
			crnCommand.setDestinationPosZ((short) Utils.getLev(idleLocNo)); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(idleLocNo), Utils.getBay(idleLocNo), Utils.getLev(idleLocNo));
			steThread.modifyPos(Utils.getGroupRow(idleLocNo, true), Utils.getBay(idleLocNo), Utils.getLev(idleLocNo));
			// 修改工作档状态 3.小车待搬 => 5.迁出小车
			Date now = new Date();
			wrkMast.setWrkSts(5L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 3.小车待搬 => 5.迁出小车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬 => 5.迁出小车失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1626,7 +1706,6 @@
			/**
			* 执行对工作档的完成操作
			*/
			@Async
			@Transactional
			public void storeFinished() {
			for (CrnSlave crn : slaveProperties.getCrn()) {
			@@ -1643,7 +1722,18 @@
			// 充电任务
			WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
			if (wrkCharge == null) {
			log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			wrkMast = wrkMastMapper.selectCrnWaiting2(crnProtocol.getTaskNo().intValue());
			if (wrkMast.getIoType() != 11) {
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			News.error("堆垛机处于等待确认且任务完成状态,复位，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			} else {
			News.error("堆垛机处于等待确认且任务完成状态,复位失败，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			}
			}
			continue;
			} else {
			// 小车搬至指定库位完成
			@@ -1651,28 +1741,70 @@
			// 23.吊车搬运 ===>> 24.小车到达
			wrkCharge.setWrkSts(24L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 27) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (steThread.confirmPos()) {
			// 27.放至充电位 ===>> 28.充电就绪
			wrkCharge.setWrkSts(28L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改充电任务状态 27.放至充电位 ===>> 28.充电就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			} else if (wrkCharge.getWrkSts() == 34) {
			// 34.吊车搬运 ===>> 35.小车就绪
			wrkCharge.setWrkSts(35L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 34.吊车搬运 ===>> 35.小车就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 34.吊车搬运 ===>> 35.小车就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 42) {
			// 42.吊车搬运 ===>> 43.小车到达
			wrkCharge.setWrkSts(43L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改复位任务状态 42.吊车搬运 ===>> 43.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			News.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 46) {
			// 46.放至待机位 ===>> 47.复位成功
			wrkCharge.setWrkSts(47L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改复位任务状态 46.放至待机位 ===>> 47.复位成功失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (!steThread.confirmPos()) {
			News.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			}
			}
			}
			@@ -1684,7 +1816,7 @@
			// 入库 ==>> 货物搬入库
			if (wrkMast.getWrkSts() == 7){
			// 判断是否需要小车入库
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
			// ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			Date now = new Date();
			@@ -1695,7 +1827,7 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 给穿梭车下发命令
			@@ -1710,7 +1842,7 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			@@ -1721,12 +1853,12 @@
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			// 入库 ===>> 迁入小车完成
			// 入库 ===>> 迁入小车完成
			} else if (wrkMast.getWrkSts() == 4) {
			// 4.迁入小车 ==> 6.小车待入
			wrkMast.setWrkSts(6L);
			@@ -1740,7 +1872,7 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			@@ -1752,10 +1884,10 @@
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			} else if (wrkMast.getWrkSts() == 5) {
			@@ -1771,7 +1903,7 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			@@ -1783,10 +1915,10 @@
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 5.迁出小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 出库 ===>> 迁入小车完成
			} else if (wrkMast.getWrkSts() == 13) {
			@@ -1797,7 +1929,7 @@
			if (steProtocol == null) { continue; }
			// 穿梭车重新定位排列层
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			@@ -1805,148 +1937,40 @@
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 搬出库
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 13.迁入小车 ==> 14.小车搬出库
			wrkMast.setWrkSts(14L);
			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) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			// 移库 ===>> 堆垛机搬至目标库位组完成
			}
			// 库位移转
			} else {
			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);
			}
			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);
			} else if (wrkMast.getWrkSts() == 16) {
			// 16.吊车出库中 ==> 17.出库完成
			wrkMast.setWrkSts(17L);
			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) {
			// 堆垛机复位
			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());
			}
			News.error("修改工作档状态 16.吊车出库中 ==> 17.出库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -1980,23 +2004,33 @@
			// 21.准备充电 ===>> 22.小车待搬
			wrkCharge.setWrkSts(22L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			} else if (wrkCharge.getWrkSts() == 25) {
			// 25.小车去充电 ===>> 26.等待充电
			// 25.小车走行 ===>> 26.等待充电
			wrkCharge.setWrkSts(26L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 25.小车走行 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			} else if (wrkCharge.getWrkSts() == 32) {
			}
			// else if (wrkCharge.getWrkSts() == 29) {
			// // 29.开始充电 ===>> 30.完成充电
			// wrkCharge.setWrkSts(30L);
			// if (!wrkChargeService.updateById(wrkCharge)) {
			// News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			// } else {
			// steThread.setResetFlag(true);
			// }
			// }
			else if (wrkCharge.getWrkSts() == 32) {
			// 32.小车走行 ===>> 33.小车待搬
			wrkCharge.setWrkSts(33L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改演示任务状态 32.小车走行 ===>> 33.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2004,7 +2038,15 @@
			// 36.小车走行 ===>> 37.演示完成
			wrkCharge.setWrkSts(37L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			} else if (wrkCharge.getWrkSts() == 44) {
			// 44.小车走行 ===>> 45.小车待搬
			wrkCharge.setWrkSts(45L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改演示任务状态 44.小车走行 ===>> 45.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2019,7 +2061,7 @@
			wrkMast.setWrkSts(3L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 2.设备上走 => 3.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2029,7 +2071,7 @@
			wrkMast.setWrkSts(9L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 8.小车搬入库 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 8.小车搬入库 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2040,11 +2082,13 @@
			wrkMast.setWrkSts(12L);
			} else {
			if (Cools.isEmpty(wrkMast.getMk())) {
			log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
			News.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
			} else {
			if (wrkMast.getMk().equals("I")) {
			String locNo = wrkMast.getLocNo();
			if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
			if (Utils.getGroupRow(locNo, false).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), false))
			&& steProtocol.getBay() == Utils.getBay(locNo)
			&& steProtocol.getLev() == Utils.getLev(locNo)) {
			// 修改工作档状态 11.生成出库ID => 6.小车待入
			wrkMast.setWrkSts(6L);
			} else {
			@@ -2059,7 +2103,7 @@
			}
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 12.小车待搬失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2069,7 +2113,7 @@
			wrkMast.setWrkSts(15L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 14.小车搬出库 => 15.等待吊车失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 14.小车搬出库 => 15.等待吊车失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2088,7 +2132,7 @@
			this.recCrnErr();
			this.recSteErr();
			} catch (Exception e) {
			log.error("recErr fail", e);
			News.error("recErr fail", e);
			}
			}

			@@ -2140,7 +2184,7 @@
			"任务中异常" // 备注
			);
			if (!basErrLogService.insert(basErrLog)) {
			log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			News.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			}
			}
			} else {
			@@ -2150,7 +2194,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basErrLogService.updateById(latest)) {
			log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			News.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			}
			}
			}
			@@ -2187,7 +2231,7 @@
			"无任务异常" // 备注
			);
			if (!basErrLogService.insert(basErrLog)) {
			log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			News.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
			}
			}
			// 无异常
			@@ -2198,7 +2242,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basErrLogService.updateById(latest)) {
			log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			News.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
			}
			}
			}
			@@ -2254,7 +2298,7 @@
			"任务中异常" // 备注
			);
			if (!basSteErrLogService.insert(basSteErrLog)) {
			log.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			News.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			}
			}
			} else {
			@@ -2264,7 +2308,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basSteErrLogService.updateById(latest)) {
			log.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			News.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			}
			}
			}
			@@ -2301,7 +2345,7 @@
			"无任务异常" // 备注
			);
			if (!basSteErrLogService.insert(basSteErrLog)) {
			log.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			News.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
			}
			}
			// 无异常
			@@ -2312,7 +2356,7 @@
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basSteErrLogService.updateById(latest)) {
			log.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			News.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
			}
			}
			}
			@@ -2326,7 +2370,6 @@
			/**
			* 空栈板初始化入库,叉车入库站放货
			*/
			@Async
			public void storeEmptyPlt(){
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历空板入库口
			@@ -2353,7 +2396,7 @@
			if (barcodeThread != null) {
			String barcode0 = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode0)) {
			// log.info("{}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode0);
			// News.info("{}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode0);
			if(!"NG".endsWith(barcode0) && !"NoRead".equals(barcode0) && !"empty".equals(barcode0)) {
			barcode = barcode0;
			}
			@@ -2371,7 +2414,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")
			@@ -2398,7 +2441,7 @@
			MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(3, errorMsg));
			}
			}
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}
			} catch (Exception e) {
			e.printStackTrace();
			@@ -2415,7 +2458,6 @@
			/**
			* 出库 ===>> 工作档信息写入led显示器
			*/
			@Async
			public void ledExecute() {
			for (LedSlave led : slaveProperties.getLed()) {
			// 获取输送线plc线程
			@@ -2459,21 +2501,15 @@
			ledCommand.setEmptyMk(true);
			break;
			default:
			log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
			News.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
			break;
			}
			ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
			ledCommand.setLocNo(wrkMast.getLocNo());
			ledCommand.setStaNo(wrkMast.getStaNo());
			if (wrkMast.getIoType() != 110) {
			if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
			List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
			wrkDetls.forEach(wrkDetl -> {
			if (wrkMast.getIoType() == 101) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getAnfme()));
			}
			if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() \|\| 0 == wrkDetl.getInspect())) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getAnfme()));
			}
			});
			wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(),wrkDetl.getSpecs())));
			}
			commands.add(ledCommand);
			}
			@@ -2486,9 +2522,20 @@
			}
			// 命令下发 -------------------------------------------------------------------------------
			if (!commands.isEmpty()) {
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			continue;
			if (led.getId()>3){
			if (!MessageQueue.offer(SlaveType.Led, led.getId()-3, new Task(1, commands))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId()-3, led.getIp(), led.getPort());
			continue;
			}else {
			ledThread.setLedMk(false);
			}
			}else {
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			continue;
			}else {
			ledThread.setLedMk(false);
			}
			}
			}

			@@ -2516,8 +2563,36 @@
			/**
			* 其他 ===>> LED显示器复位，显示默认信息
			*/
			@Async
			public void ledReset() {
			for (LedSlave led : slaveProperties.getLed()) {

			// 获取输送线plc线程
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
			// 命令集合
			boolean reset = true;
			for (Integer staNo : led.getStaArr()) {
			// 获取叉车站点
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			if (staProtocol == null) {
			continue;
			}
			if (staProtocol.getWorkNo() != 0 && staProtocol.isLoading()) {
			reset = false;
			break;
			}
			}
			// 获取led线程
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
			// led显示默认内容
			if (reset && !ledThread.isLedMk()) {
			ledThread.setLedMk(true);
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(4, new ArrayList<>()))) {
			News.error(" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			} else {

			}
			}
			}
			for (LedSlave led : slaveProperties.getLed()) {
			// 获取输送线plc线程
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
			@@ -2533,11 +2608,12 @@
			}
			}
			// 获取led线程
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getDevpPlcId());
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
			// led显示默认内容
			if (reset) {
			if (reset && !ledThread.isLedMk()) {
			ledThread.setLedMk(true);
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			}
			}
			}
			@@ -2546,7 +2622,18 @@
			/**
			* 小车电量检测 ===>> 发起充电
			*/
			@SuppressWarnings("serial")
			public synchronized void loopSteCharge() {
			if (!Cools.isEmpty(wrkMastMapper.selectAllC())){
			return;
			}
			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());
			SteProtocol steProtocol = steThread.getSteProtocol();
			@@ -2557,6 +2644,7 @@
			if (steProtocol.getMode() == 0
			\|\| !steProtocol.statusType.equals(SteStatusType.IDLE)
			\|\| basSte.getPakMk().equals("Y")
			\|\| basSte.getAutoCharge().equals("N")
			// \|\| steProtocol.getChargeStatus() == 1
			) {
			continue;
			@@ -2567,140 +2655,625 @@
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
			continue;
			}
			WrkCharge wrkCharge = wrkChargeService.selectWorking(steProtocol.getSteNo().intValue());
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);

			if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
			String idleLoc = basSte.getIdleLoc();
			// 寻找空闲充电桩
			SteChargeType steCharge = null;
			do {
			String locNo;
			if (devpThread.charge0) {
			SteChargeType first = SteChargeType.FIRST;
			locNo = first.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null
			&& wrkChargeService.selectWorkingOfCharge(first.ssbm) == null) {
			steCharge = first;
			break;
			}
			}
			// if (!devpThread.charge1) {
			// SteChargeType second = SteChargeType.SECOND;
			// locNo = second.locNo;
			// if (basSteService.hasCarOfLocNo(locNo) == null
			// && wrkChargeService.selectWorkingOfCharge(second.ssbm) == null) {
			// steCharge = second;
			// break;
			// }
			// }
			// if (!devpThread.charge2) {
			// SteChargeType third = SteChargeType.THIRD;
			// locNo = third.locNo;
			// if (basSteService.hasCarOfLocNo(locNo) == null
			// && wrkChargeService.selectWorkingOfCharge(third.ssbm) == null) {
			// steCharge = third;
			// break;
			// }
			// }
			break;
			} while (false);

			if (steCharge == null) {
			// News.warn("{}号小车【电量：{}】充电失败，原因：没有空闲充电桩。", ste.getId(), steProtocol.getCharge());
			continue;
			}
			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(basSte.getCrnNo());
			wrkCharge.setCrnNo(1); // 固定1号堆垛机
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setLocNo(idleLoc);
			wrkCharge.setLocNo(chargeLocNo);
			wrkCharge.setMemo("charge");
			wrkCharge.setAppeTime(new Date());
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
			News.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
			continue;
			}

			// 处于充电库位组
			if (Utils.getGroupRow(idleLoc).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(idleLoc) && steProtocol.getLev() == Utils.getLev(idleLoc)) {
			if ( 0<steProtocol.getRow().intValue() && steProtocol.getRow().intValue()<=4
			&& steProtocol.getBay().intValue() == Utils.getBay(chargeLocNo)
			&& steProtocol.getLev().intValue() == Utils.getLev(chargeLocNo)) {
			// 修改工作档状态 21.准备充电 => 24.小车到达
			wrkCharge.setWrkSts(24L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			this.letCarBeWaiting(wrkCharge, ste.getId());
			}

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

			/**
			* 执行小车充电任务
			*/
			public synchronized void executeSteCharge() {
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, 1);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (null == wrkCharge) {
			try{
			if (steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()){
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(1); // 穿梭车编号
			steCommand.setTaskNo(10060); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
			if (!MessageQueue.offer(SlaveType.Ste, 1, new Task(2, steCommand))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			}
			}
			}catch (Exception e){
			return;
			}
			return;
			}
			Integer steNo = wrkCharge.getSteNo();

			// 22.小车待搬
			if (wrkCharge.getWrkSts() == 22) {
			// 搬小车至充电库位
			LocMast locMast = locMastService.selectById(basSte.getIdleLoc());
			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())+40) {
			MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
			wrkCharge.setWrkSts(30L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}else {
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			}
			}
			return;
			}else if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine()) && steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()) {
			MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
			wrkCharge.setWrkSts(30L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}else {
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			}
			}
			return;
			}
			try {
			// filter
			if (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1) {
			return;
			}

			// 堆垛机命令下发区 --------------------------------------------------------------------------
			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()).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.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());
			}
			}
			// 22.小车待搬
			if (wrkCharge.getWrkSts() == 22) {

			} 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.findChargeByLoc(steProtocol.getRow().intValue()));
			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) {
			if (steProtocol.getChargeStatus() == 0) { continue; }
			// 给输送线下发充电任务
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			SteChargeType steChargeType = SteChargeType.get(wrkCharge.getLocNo());
			if (null != steChargeType) {
			if (devpThread.charge(steChargeType.ssbm - 1, true)) {
			// 修改工作档状态 26.等待充电 ===> 28.完成充电
			wrkCharge.setWrkSts(28L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 26.等待充电 ===> 28.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			}
			} else {
			log.error("获取充电桩号失败，解析库位：{}", wrkCharge.getLocNo());
			// 入出库任务优先
			if (null != wrkMastMapper.selectWorkingByCrn(wrkCharge.getCrnNo())) {
			return;
			}

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

			// 搬小车至小车走向通道
			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(locMast.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 22.小车待搬 => 23.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(23L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改工作档状态 22.小车待搬 => 23.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} catch (Exception e) {
			log.error("fail", e);

			} 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.BACK_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))) {
			News.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)) {
			News.error("修改充电任务状态 24.小车到达 ===> 25.小车走行失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 26) {
			//26.等待充电 ===>
			// 穿梭车下发充电任务
			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))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 28.充电就绪 ===>> 29.开始充电
			wrkCharge.setWrkSts(29L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			} else if (wrkCharge.getWrkSts() == 29) {
			Float idle2 = steProtocol.isIdle2();
			String chargeLine = SpringUtils.getBean(BasSteService.class).selectById(1).getChargeLine();
			if (idle2<(Float.parseFloat(chargeLine)+2)){
			MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 666));//充电标记
			}else if (idle2 >= 100f){
			MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
			// 29.开始充电 ===>> 30.完成充电
			wrkCharge.setWrkSts(30L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}else {
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			}
			}
			}
			}
			} catch (Exception e) {
			News.error("executeSteCharge fail", e);
			}
			}

			/**
			* 轮询充电桩是否有空闲小车
			*/
			@Deprecated
			public synchronized void queryChargeLocOfComplete() {
			// 与充电任务不同步进行
			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()) {
			Integer steNo = basSteService.hasCarOfLocNo(value.locNo);
			if (steNo != null) {
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(steNo);
			if (Cools.isEmpty(steProtocol, basSte)) {
			continue;
			}
			if (steProtocol.getCharge() < 99) {
			continue;
			}
			if (steProtocol.getMode() == 0) {
			continue;
			}
			if (!steProtocol.getStatusType().equals(SteStatusType.IDLE)) {
			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())) {
			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)) {
			News.error("保存{}号穿梭车复位任务失败!!!", steNo);
			} else {
			break;
			}
			}
			}
			}
			}

			/**
			* 小车从充电桩至待机库位
			*/
			@Deprecated
			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) {
			News.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))) {
			News.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)) {
			News.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))) {
			News.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)) {
			News.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) {
			News.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))) {
			News.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)) {
			News.error("修改工作档状态 45.小车待搬 => 46.放至待机位失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}

			}
			}
			}


			public List<String> crn1DemoLocs = new ArrayList<String>(); public String crn1LastLoc = "";
			public List<String> crn2DemoLocs = new ArrayList<String>(); public String crn2LastLoc = "";
			public List<String> crn3DemoLocs = new ArrayList<String>(); public String crn3LastLoc = "";
			public synchronized void demo() {
			if (Cools.isEmpty(crn1DemoLocs)) {
			crn1DemoLocs = locMastService.getDemoNextLoc(1);
			/**
			* 因双深库位阻塞，对浅库位进行移转（出库版)
			* tip：同步
			*/
			private void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
			try {
			List<Integer> rows = locMastService.queryDistinctRow(crn.getId());
			LocMast loc = null;
			for (Integer row : rows) {
			if (Utils.isDeepLoc(slaveProperties, row)) {
			loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1());

			if (loc != null) {
			if (Utils.isDeepLoc(slaveProperties, loc.getLocNo())) {
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
			LocMast shallowLoc1 = locMastService.selectById(shallowLocNo);
			if (!shallowLoc1.getLocSts().equals("O")) {
			loc = null;
			}
			}
			}

			if (null != loc) {
			break;
			}
			}
			}
			if (null == loc) {
			for (Integer row : rows) {
			if (Utils.isShallowLoc(slaveProperties, row)) {
			loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1());

			if (null != loc) {//对应深库位非在库状态,不能移库
			String deepLoc = Utils.getDeepLoc(slaveProperties, loc.getLocNo());
			LocMast deepLoc1 = locMastService.selectById(deepLoc);
			if (!deepLoc1.getLocSts().equals("F") && !deepLoc1.getLocSts().equals("D")) {
			loc = null;
			}
			}

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

			// 获取工作号
			int workNo = commonService.getWorkNo(0);
			// 保存工作档
			WrkMast wrkMast = new WrkMast();
			wrkMast.setWrkNo(workNo);
			wrkMast.setIoTime(new Date());
			wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
			wrkMast.setIoType(11); // 入出库状态： 11.库格移载
			wrkMast.setIoPri(20D);
			wrkMast.setCrnNo(crn.getId());
			wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
			wrkMast.setLocNo(loc.getLocNo()); // 目标库位
			wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
			wrkMast.setPicking("N"); // 拣料
			wrkMast.setExitMk("N"); // 退出
			wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
			wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
			wrkMast.setLinkMis("N");
			wrkMast.setAppeTime(new Date());
			wrkMast.setModiTime(new Date());
			int res = wrkMastMapper.insert(wrkMast);
			if (res == 0) {
			News.error("双深库位 --- 保存工作档失败！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("保存工作档失败");
			}
			// 工作档明细保存
			if (shallowLoc.getLocSts().equals("F")) {
			List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
			for (LocDetl locDetl : locDetls) {
			WrkDetl wrkDetl = new WrkDetl();
			wrkDetl.sync(locDetl);
			wrkDetl.setWrkNo(workNo);
			wrkDetl.setIoTime(new Date());
			wrkDetl.setAnfme(locDetl.getAnfme());
			wrkDetl.setAppeTime(new Date());
			wrkDetl.setModiTime(new Date());
			if (!wrkDetlService.insert(wrkDetl)) {
			News.error("双深库位 --- 保存工作档明细失败！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("保存工作档明细失败");
			}
			}
			}
			// 修改源库位状态
			if (shallowLoc.getLocSts().equals("D") \|\| shallowLoc.getLocSts().equals("F")) {
			shallowLoc.setLocSts("R"); // R.出库预约
			shallowLoc.setModiTime(new Date());
			if (!locMastService.updateById(shallowLoc)) {
			News.error("双深库位 --- 更新源库位状态失败！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("更新源库位状态失败");
			}
			} else {
			News.error("双深库位 --- 源库位出库失败！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("源库位出库失败");
			}
			// 修改目标库位状态
			if (loc.getLocSts().equals("O")) {
			loc.setLocSts("S"); // S.入库预约
			loc.setModiTime(new Date());
			if (!locMastService.updateById(loc)) {
			News.error("双深库位 --- 更新目标库位状态失败！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("更新目标库位状态失败");
			}
			} else {
			News.error("双深库位 --- 移转失败！待移转浅库位：" + shallowLoc.getLocNo());
			throw new CoolException("移转失败");
			}
			} catch (Exception e) {
			News.error("双深库位阻塞，对浅库位进行移转失败", e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}

			public List<String> crn2DemoLocs = new ArrayList<String>(); public String crn2LastLoc = "";
			public synchronized void demo() {
			if (Cools.isEmpty(crn2DemoLocs)) {
			crn2DemoLocs = locMastService.getDemoNextLoc(2);
			}
			if (Cools.isEmpty(crn3DemoLocs)) {
			crn3DemoLocs = locMastService.getDemoNextLoc(3);
			}
			for (CrnSlave crn : slaveProperties.getCrn()) {
			if (!crn.getDemo()) {
			continue;
			} // 必须为演示状态

			}
			// 必须为演示状态
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) {
			@@ -2716,8 +3289,12 @@
			continue;
			}

			int steNo = crn.getId();
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteThread steThread = queryIdleCar(crnProtocol);
			if (Cools.isEmpty(steThread)) {
			News.warn("没有空闲的小车进行演示功能");
			continue;
			}
			int steNo = steThread.getSlave().getId();
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(steNo);
			if (Cools.isEmpty(steProtocol, basSte)) { continue; }
			@@ -2726,26 +3303,14 @@
			if (steProtocol.isIdle()) {

			String locNo = null;
			Iterator<String> iterator = crn1DemoLocs.iterator();
			if (crn.getId() == 1) {
			iterator = crn1DemoLocs.iterator();
			} else if (crn.getId() == 2) {
			iterator = crn2DemoLocs.iterator();
			} else if (crn.getId() == 3) {
			iterator = crn3DemoLocs.iterator();
			}
			Iterator<String> iterator = crn2DemoLocs.iterator();
			while (iterator.hasNext()) {
			String next = iterator.next();
			String lastLoc = "";
			if (crn.getId() == 1) {
			lastLoc = crn1LastLoc;
			} else if (crn.getId() == 2) {
			lastLoc = crn2LastLoc;
			} else if (crn.getId() == 3) {
			lastLoc = crn3LastLoc;
			}
			if (!Cools.isEmpty(this.hasCar(next))) { continue; }
			String lastLoc = crn2LastLoc;
			if (!Cools.isEmpty(lastLoc)) {
			if (!lastLoc.substring(2, 7).equals(next.substring(2, 7)) \|\| !Utils.getGroupRow(lastLoc).equals(Utils.getGroupRow(next))) {
			if (!lastLoc.substring(2, 7).equals(next.substring(2, 7))
			\|\| !Utils.getGroupRow(lastLoc, true).equals(Utils.getGroupRow(next, true))) {
			locNo = next;
			iterator.remove();
			break;
			@@ -2760,16 +3325,10 @@

			}
			if (!Cools.isEmpty(locNo)) {
			if (crn.getId() == 1) {
			crn1LastLoc = locNo;
			} else if (crn.getId() == 2) {
			crn2LastLoc = locNo;
			} else if (crn.getId() == 3) {
			crn3LastLoc = locNo;
			}
			crn2LastLoc = locNo;
			}

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

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

			@@ -2783,7 +3342,7 @@
			wrkCharge.setLocNo(locNo);
			wrkCharge.setMemo("demo");
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("生成演示任务失败，堆垛机号：{}，小车：{}，源库位：{}，目标库位：{}", crn.getId(), steNo, sourceLocNo, locNo);
			News.error("生成演示任务失败，堆垛机号：{}，小车：{}，源库位：{}，目标库位：{}", crn.getId(), steNo, sourceLocNo, locNo);
			}
			}
			}
			@@ -2810,7 +3369,7 @@
			wrkCharge.setWrkSts(32L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务{}工作档 31.生成演示ID ==>> 32.小车走行失败!", wrkCharge.getWrkNo());
			News.error("修改演示任务{}工作档 31.生成演示ID ==>> 32.小车走行失败!", wrkCharge.getWrkNo());
			}
			// 33.小车待搬
			} else if (wrkCharge.getWrkSts() == 33L) {
			@@ -2821,32 +3380,32 @@
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue()); // 源库位排
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue()); // 目标库位排
			crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 33.小车待搬 => 34.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(34L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务{}工作档 33.小车待搬 => 34.吊车搬运失败!", wrkCharge.getWrkNo());
			News.error("修改演示任务{}工作档 33.小车待搬 => 34.吊车搬运失败!", wrkCharge.getWrkNo());
			}
			}
			// 35.小车就绪
			// 35.小车就绪
			} else if (wrkCharge.getWrkSts() == 35L) {

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

			@@ -2854,7 +3413,7 @@
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			SteTaskModeType originByLoc = SteTaskModeType.findOriginByLoc(steProtocol.getRow());
			SteTaskModeType originByLoc = SteTaskModeType.findOriginByLoc(steProtocol.getRow().intValue());
			if (originByLoc.equals(SteTaskModeType.GO_ORIGIN)) {
			originByLoc = SteTaskModeType.BACK_ORIGIN;
			} else if (originByLoc.equals(SteTaskModeType.BACK_ORIGIN)) {
			@@ -2864,24 +3423,81 @@
			}
			steCommand.setTaskMode(originByLoc);

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).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));
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 35.小车就绪 => 36.小车走行
			wrkCharge.setWrkSts(36L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务{}工作档 35.小车就绪 => 36.小车走行失败!", wrkCharge.getWrkNo());
			News.error("修改演示任务{}工作档 35.小车就绪 => 36.小车走行失败!", wrkCharge.getWrkNo());
			}
			}
			}
			}

			}
			/**
			* 出入库模式切换
			*/
			public synchronized void outAndIn() {
			try {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			for (DevpSlave.Sta inSta : devp.getInSta()) {
			Thread.sleep(500);
			boolean a=true,b=true;
			List<WrkMast> wrkMasts = wrkMastMapper.selectAll(inSta.getStaNo());
			if (Cools.isEmpty(wrkMasts)){
			b=false;
			}else {
			for (WrkMast wrkMast:wrkMasts){
			if (wrkMast.getSourceStaNo() > wrkMast.getStaNo()){
			a=false;
			break;
			}
			}
			}
			switch (inSta.getStaNo()) {
			case 102://1F
			if (a && b){
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 11));
			}else if (b){
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 12));
			}else {
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 10));
			}
			break;
			case 202://2F
			if (a && b){
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 21));
			}else if (b){
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 22));
			}else {
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 20));
			}
			break;
			case 302://3F
			if (a && b){
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 31));
			}else if (b){
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 32));
			}else {
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, 30));
			}
			break;
			}
			}
			}

			} catch (Exception e) {
			e.printStackTrace();
			}
			}


			}