zy-wcs.git - Gitblit

			@@ -4,20 +4,17 @@
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			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.*;
			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.service.erp.ErpService;
			import com.zy.common.utils.CollectionUtils;
			import com.zy.common.utils.HttpHandler;
			import com.zy.common.utils.*;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.News;
			@@ -25,17 +22,13 @@
			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;
			@@ -95,6 +88,8 @@
			private OrderMapper orderMapper;
			@Autowired
			private OrderDetlMapper orderDetlMapper;
			@Autowired
			private RedisUtil redisUtil;

			/**
			* 组托
			@@ -114,59 +109,51 @@
			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()
			&& !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;
			}

			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			@@ -176,7 +163,7 @@
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode)) {
			// News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "empty".equals(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);
			@@ -407,7 +394,6 @@
			if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) {
			wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
			if (null == wrkMast) {
			News.error("{}任务号错误，暂无拣料任务！", staProtocol.getWorkNo());
			continue;
			}
			} else {
			@@ -620,6 +606,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((short) 0);
			//源库位
			assignCommand.setSourceLocNo(wrkSts.getSourceLocNo());
			//目标库位
			assignCommand.setDistLocNo(wrkSts.getLocNo());

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

			}
			}

			}

			/**
			* 入出库 ===>> 堆垛机入出库作业下发
			*/
			public synchronized void crnIoExecute(){
			@@ -666,7 +697,7 @@
			// 库位移转
			// this.locToLoc(crn, crnProtocol);
			// 演示
			this.steMoveDemo(crn, crnProtocol);
			// this.steMoveDemo(crn, crnProtocol);
			}
			}
			}
			@@ -726,6 +757,51 @@
			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)) {
			News.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
			@@ -733,120 +809,100 @@
			}

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

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

			// 非穿梭库入库【堆垛机直接入库】
			if (wrkMast.getWrkSts() == 2) {

			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
			// 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
			Integer steNo = this.hasCar(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
			// 没有其他任务
			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 {

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) {
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo());
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			// 当前入库库位组没有小车堆垛机则去站点取货入库
			// case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
			// case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
			if ((wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) \|\| wrkMast.getWrkSts() == 6L) {

			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}

			// 堆垛机入库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排
			crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(locMast.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			} else {
			if (waitWrkMast.getWrkSts() < 17) {
			waitWrkMast.setIoPri(30D);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			//20220719 Add，如果浅库位状态为P/R，工作状态为14/15,说明浅库位已经空了，可以执行入库任务
			}
			}
			continue;
			}
			if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			// 此标记避免多次执行移库任务
			if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())) {
			wrkMast.setUpdMk("Y");
			wrkMast.setIoPri(20D);
			wrkMastMapper.updateById(wrkMast);
			// 生成工作档、改变浅库位的源库/目标库库位状态、下发堆垛机命令（立马执行)
			moveLocForDeepLoc(slave, shallowLoc);
			}
			continue;
			}
			if (shallowLoc.getLocSts().equals("Q")) {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null != waitWrkMast && waitWrkMast.getWrkSts() == 9) {
			continue;
			return true;
			}
			}
			}

			// 堆垛机入库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排
			crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(locMast.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			}

			// 目标库位 ===>> 非最外层库位
			} else {
			// 判断小车是否在当前组库位，如果是则将穿梭车移至最外层，等待堆垛机放货；如果不是，则堆垛机寻找穿梭车，并放置当前组最外层
			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;
			}
			}
			}
			} else {
			// 目标库位 ===>> 最外层库位
			if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
			// 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
			Integer steNo = this.hasCar(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
			// 没有其他任务
			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 {

			// 当前入库库位组没有小车堆垛机则去站点取货入库
			// case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
			// case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
			if ((wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) \|\| wrkMast.getWrkSts() == 6L) {
			// 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入 ===>> 7.吊车入库中
			if (wrkMast.getWrkSts() == 3L \|\| wrkMast.getWrkSts() == 6L) {
			// 小车处于空闲
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (steProtocol.isIdle()) {

			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}

			// 堆垛机入库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			@@ -856,105 +912,46 @@
			crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排
			crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(locMast.getRow1().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))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 7.吊车入库中
			// 修改工作档状态 3.小车待搬 ===>> 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 {} => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			}

			}

			// 目标库位 ===>> 非最外层库位
			// 没有小车
			} else {
			// 判断小车是否在当前组库位，如果是则将穿梭车移至最外层，等待堆垛机放货；如果不是，则堆垛机寻找穿梭车，并放置当前组最外层
			Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
			// 有小车
			if (steNo != null) {
			// 小车行走到待机位
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
			// 寻找当前堆垛机对应的小车
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			// 没有其他任务
			if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			} else {
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
			return true;
			}
			}
			// 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入 ===>> 7.吊车入库中
			if (wrkMast.getWrkSts() == 3L \|\| wrkMast.getWrkSts() == 6L) {
			// 小车处于空闲
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (steProtocol.isIdle()) {

			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}
			// 堆垛机入库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排
			crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(crnStn.getLev().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))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 3.小车待搬 ===>> 7.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(7L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			}
			}
			// 没有小车
			} else {
			if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
			// 寻找当前堆垛机对应的小车
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			// 没有其他任务
			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;
			}
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 3L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			return true;
			}
			}
			}

			}
			return false;
			}
			@@ -978,6 +975,36 @@
			LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
			if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
			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;
			}

			@@ -1029,50 +1056,19 @@
			}

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

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

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			if(waitWrkMast.getWrkSts() == 11) {
			waitWrkMast.setIoPri(wrkMast.getIoPri() + 1);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			}
			continue;
			}
			} else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			// 此标记避免多次执行移库任务
			if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())) {
			wrkMast.setUpdMk("Y");
			wrkMastMapper.updateById(wrkMast);
			// 生成工作档、改变浅库位的源库/目标库库位状态、下发堆垛机命令（立马执行)
			moveLocForDeepLoc(slave, shallowLoc);
			}
			News.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
			continue;
			}
			}

			// 最外层库位，直接堆垛机出库
			if (locMastService.isOutMost(wrkMast.getSourceLocNo(), false)) {
			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}

			// 1.堆垛机开始移动
			// 堆垛机出库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			@@ -1098,143 +1094,105 @@
			return true;
			}
			}

			} else {

			// 最外层库位，直接堆垛机出库
			if (locMastService.isOutMost(wrkMast.getSourceLocNo(), false)) {
			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}

			// 堆垛机出库命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.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) {
			News.error("修改工作档状态 11.生成出库ID => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			// 不是最外层库位，需要使用穿梭车搬运后，再堆垛机出库
			} else {
			// 当前组库位是否有穿梭车
			Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
			// 有小车
			if (steNo != null) {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			} 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) { continue; }
			if (steProtocol.isIdle()) {
			// 给穿梭车下发命令让其将货物挪至堆垛机搬运点
			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.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 去近点等待堆垛机叉取
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(steNo); // 穿梭车编号
			steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式: 去近点等待堆垛机叉取

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
			steCommand.setBay(steProtocol.getBay());
			steCommand.setLev(steProtocol.getLev());
			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))) {
			News.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);
			LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			Integer outCrnNo = locMastService.getOutCrnNo(locMast);
			wrkMast.setCrnNo(outCrnNo);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			}
			}
			if (wrkMast.getWrkSts() == 15L) {
			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}

			// 堆垛机出库命令下发区 --------------------------------------------------------------------------
			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(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))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 15.等待吊车 => 16.吊车出库中
			// 修改工作档状态 11.生成出库ID => 14.小车搬出库
			Date now = new Date();
			wrkMast.setWrkSts(16L);
			wrkMast.setWrkSts(14L);
			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) {
			News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			}
			}
			if (wrkMast.getWrkSts() == 15L) {
			// 已经存在吊车执行任务时，则过滤
			if (wrkMastMapper.selectWorking(slave.getId()) != null) {
			continue;
			}

			// 没有小车
			} else {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 寻找最近的小车
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			// 没有其他任务
			if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
			// 让小车等待搬运待续
			this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
			return true;
			}
			// 堆垛机出库命令下发区 --------------------------------------------------------------------------
			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(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))) {
			News.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) {
			News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			} else {
			return true;
			}
			}
			// 堆垛机搬运小车
			if (wrkMast.getWrkSts() == 12L) {
			this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
			return true;
			}

			// 没有小车
			} else {
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 寻找最近的小车
			SteThread steThread = queryIdleCar(wrkMast);
			if (steThread != null) {
			// 没有其他任务
			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;
			@@ -1396,7 +1354,7 @@
			SteProtocol steProtocol = steThread.getSteProtocol();
			if (steProtocol == null) { continue; }
			if (!steProtocol.isIdle()) { continue; }
			if (steProtocol.getRow() == 1) { 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))
			@@ -1765,6 +1723,17 @@
			WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
			if (wrkCharge == null) {
			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 {
			// 小车搬至指定库位完成
			@@ -1846,7 +1815,8 @@
			if (wrkMast.getIoType() != 11) {
			// 入库 ==>> 货物搬入库
			if (wrkMast.getWrkSts() == 7){
			if (!locMastService.isShuttle(wrkMast.getLocNo())) {
			// 判断是否需要小车入库
			if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
			// ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			Date now = new Date();
			@@ -1860,46 +1830,30 @@
			News.error("修改工作档状态 7.吊车入库中 => 9.入库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else {
			// 判断是否需要小车入库
			if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
			// ==> 9.入库完成
			wrkMast.setWrkSts(9L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 给穿梭车下发命令
			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))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			} else {
			News.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))) {
			News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			// 修改工作档状态 7.吊车入库中 => 8.小车搬入库
			wrkMast.setWrkSts(8L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			} else {
			News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2002,20 +1956,21 @@
			}
			}
			// 移库 ===>> 堆垛机搬至目标库位组完成
			}
			// 库位移转
			} else {
			if (!locMastService.isShuttle(wrkMast.getLocNo())) {
			if (wrkMast.getWrkSts() == 16 && wrkMast.getIoType() == 11){
			// 更新工作档状态为 17.出库完成
			wrkMast.setWrkSts(17L);
			wrkMast.setCrnEndTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) != 0) {
			// 复位堆垛机
			crnThread.setResetFlag(true);
			} else {
			News.error("更新工作档的工作状态为 17.出库完成失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}
			} 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);
			} else {
			News.error("修改工作档状态 16.吊车出库中 ==> 17.出库完成失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			@@ -2061,15 +2016,17 @@
			} else {
			steThread.setResetFlag(true);
			}
			} 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) {
			}
			// 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)) {
			@@ -2548,18 +2505,11 @@
			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());
			try {
			WrkDetl wrkDetl = wrkDetls.get(0);
			if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
			OrderDetl orderDetl = orderDetlMapper.selectItemNoneOfBatch(wrkDetl.getOrderNo(), wrkDetl.getMatnr());
			ledCommand.getMatDtos().add(new MatDto(orderDetl));
			}
			} catch (Exception e) {
			News.error("led execute fail", e);
			}
			wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(),wrkDetl.getSpecs())));
			}
			commands.add(ledCommand);
			}
			@@ -2572,9 +2522,20 @@
			}
			// 命令下发 -------------------------------------------------------------------------------
			if (!commands.isEmpty()) {
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
			News.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);
			}
			}
			}

			@@ -2604,6 +2565,35 @@
			*/
			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());
			// 命令集合
			@@ -2618,9 +2608,10 @@
			}
			}
			// 获取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<>()))) {
			News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			}
			@@ -2633,6 +2624,9 @@
			*/
			@SuppressWarnings("serial")
			public synchronized void loopSteCharge() {
			if (!Cools.isEmpty(wrkMastMapper.selectAllC())){
			return;
			}
			if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) {
			return;
			}
			@@ -2668,7 +2662,7 @@
			SteChargeType steCharge = null;
			do {
			String locNo;
			if (!devpThread.charge0) {
			if (devpThread.charge0) {
			SteChargeType first = SteChargeType.FIRST;
			locNo = first.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null
			@@ -2677,24 +2671,24 @@
			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;
			}
			}
			// 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);

			@@ -2708,7 +2702,7 @@
			wrkCharge.setCharge(steCharge.ssbm);
			wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
			wrkCharge.setWrkSts(21L); // 21.准备充电
			wrkCharge.setCrnNo(2); // 固定2号堆垛机
			wrkCharge.setCrnNo(1); // 固定1号堆垛机
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setLocNo(chargeLocNo);
			wrkCharge.setMemo("charge");
			@@ -2718,49 +2712,15 @@
			continue;
			}

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

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

			// 处于充电库位组
			if (steProtocol.getRow().intValue() == Utils.getRow(chargeLocNo)
			if ( 0<steProtocol.getRow().intValue() && steProtocol.getRow().intValue()<=4
			&& steProtocol.getBay().intValue() == Utils.getBay(chargeLocNo)
			&& steProtocol.getLev().intValue() == Utils.getLev(chargeLocNo)) {
			// 修改工作档状态 21.准备充电 => 28.充电就绪
			wrkCharge.setWrkSts(28L);
			// 修改工作档状态 21.准备充电 => 24.小车到达
			wrkCharge.setWrkSts(24L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改充电任务状态 21.准备充电 => 28.充电就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			News.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			this.letCarBeWaiting(wrkCharge, ste.getId());
			@@ -2780,10 +2740,26 @@
			*/
			public synchronized void executeSteCharge() {
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
			if (null == wrkCharge) { return; }
			Integer steNo = wrkCharge.getSteNo();
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			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();

			BasSte basSte = basSteService.selectById(steNo);
			if (Cools.isEmpty(steProtocol, basSte)) { return; }
			if (steProtocol.getMode() == 0
			@@ -2797,9 +2773,35 @@
			if (!steProtocol.isEnable()) {
			return;
			}
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())+40) {
			MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
			wrkCharge.setWrkSts(30L);
			wrkChargeMapper.updateById(wrkCharge);
			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 {
			@@ -2816,49 +2818,39 @@
			return;
			}

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

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

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

			}
			}

			@@ -2870,7 +2862,7 @@
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN); // 去右端
			steCommand.setTaskMode(SteTaskModeType.BACK_ORIGIN); // 去右端

			steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
			steCommand.setBay(steProtocol.getBay());
			@@ -2889,49 +2881,7 @@
			}
			}
			} else if (wrkCharge.getWrkSts() == 26) {
			// 固定堆垛机
			int crnNo = 1;
			// 入出库任务优先
			if (null != wrkMastMapper.selectWorkingByCrn(crnNo)) {
			return;
			}

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

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { return; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(crnNo); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(chargeLoc.getRow1(), chargeLoc.getBay1(), chargeLoc.getLev1());
			// 修改工作档状态 26.等待充电 => 27.放至充电位
			Date now = new Date();
			wrkCharge.setWrkSts(27L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			News.error("修改工作档状态 26.等待充电 => 27.放至充电位失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 28L) {
			//26.等待充电 ===>
			// 穿梭车下发充电任务
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			@@ -2946,6 +2896,27 @@
			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);
			@@ -2955,6 +2926,7 @@
			/**
			* 轮询充电桩是否有空闲小车
			*/
			@Deprecated
			public synchronized void queryChargeLocOfComplete() {
			// 与充电任务不同步进行
			if (null != wrkChargeService.selectWorking(null, WrkChargeType.charge)) { return; }
			@@ -3031,6 +3003,7 @@
			/**
			* 小车从充电桩至待机库位
			*/
			@Deprecated
			public synchronized void steFromChargeToIdleLoc() {
			WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.reset);
			if (wrkCharge == null) { return; }
			@@ -3468,6 +3441,63 @@
			}

			}
			/**
			* 出入库模式切换
			*/
			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();
			}
			}


			}