zy-wcs.git - Gitblit

			@@ -10,6 +10,7 @@
			import com.zy.asrs.entity.*;
			import com.zy.asrs.mapper.*;
			import com.zy.asrs.service.*;
			import com.zy.system.service.*;
			import com.zy.asrs.utils.RouteUtils;
			import com.zy.asrs.utils.Utils;
			import com.zy.asrs.utils.VersionUtils;
			@@ -38,6 +39,9 @@
			import com.zy.core.thread.LedThread;
			import com.zy.core.thread.RgvThread;
			import com.zy.core.thread.SiemensDevpThread;
			import com.zy.system.entity.Config;
			import com.zy.system.mapper.ConfigMapper;
			import com.zy.system.service.ConfigService;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			@@ -45,7 +49,10 @@
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;

			import java.io.IOException;
			import java.text.SimpleDateFormat;
			import java.util.*;
			import java.util.concurrent.ConcurrentHashMap;
			import java.util.concurrent.TimeUnit;
			import java.util.stream.Collectors;

			@@ -94,6 +101,8 @@
			private WrkMastService wrkMastService;
			@Autowired
			private BasRgvMapService basRgvMapService;
			@Autowired
			private ConfigService configService;

			@Value("${wms.url}")
			private String wmsUrl;
			@@ -101,12 +110,9 @@
			private boolean isToOrigin;

			public Integer wrkNo = 10000;

			/**
			* 组托
			* 入库站，根据条码扫描生成入库工作档，工作状态 2
			*/
			public synchronized void generateStoreWrkFile(Integer mark) {
			@Autowired
			private ConfigMapper configMapper;
			public synchronized void generateStoreWrkFile3(Integer mark) {
			String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			@@ -117,16 +123,23 @@
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			StaProtocol staProtocolIn = devpThread.getStation().get(inSta.getStaNo() -1);
			if (staProtocolIn == null) {
			continue;
			} else {
			staProtocolIn = staProtocolIn.clone();
			}
			if (barcodeThread == null) {
			continue;
			}
			String barcode = barcodeThread.getBarcode();

			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			if (barcodeThread == null) {
			continue;
			}
			String barcode = barcodeThread.getBarcode();
			// 尺寸检测异常
			boolean back = false;
			String errMsg = "";
			@@ -218,7 +231,7 @@
			//
			// }
			News.error(barcode + "条码已存在状态为（ 2.设备上走）的数据,请查看WCS输送线界面,工作号={}", wrkMast.getWrkNo());
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, barcode + "条码已存在状态为（ 2.设备上走）的任务,工作号=" + wrkMast.getWrkNo()));
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, barcode + "条码已存在状态为（ 2.设备上走）的任务,工作号=" + wrkMast.getWrkNo()));
			continue;
			// barcodeThread.setBarcode("");
			// staProtocol.setWorkNo(wrkMast.getWrkNo());
			@@ -283,27 +296,6 @@
			}
			} else {
			if (jsonObject.getString("msg").equals("工作档已存在")) {

			//工作档已存在再次进去
			// wrkMast = wrkMastMapper.selectPakInStepBarcode(barcode);
			// if (wrkMast != null) {
			// barcodeThread.setBarcode("");
			// staProtocol.setWorkNo(9999);
			// //staProtocol.setWorkNo(wrkMast.getWrkNo());
			// //staProtocol.setStaNo(RouteUtils.SouStaEnd(dto.getStaNo(),dto.getSourceStaNo()));
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发2：" + wrkMast.getWrkNo() + "," + wrkMast.getStaNo());
			// ledThread.errorReset();
			// log.error("组托请求后LED错误清除");
			// if (!result) {
			// News.error(methodName + ":更新plc站点信息失败");
			//
			// throw new CoolException("更新plc站点信息失败");
			// }
			// }

			continue;
			}
			staProtocol.setWorkNo(wrkNo);
			@@ -336,6 +328,436 @@
			// News.infoNoLog(""+mark+" - 0"+" - 组托 ===》执行完成");

			}
			/**
			* 组托
			* 入库站，根据条码扫描生成入库工作档，工作状态 2
			*/
			// public synchronized void generateStoreWrkFile(Integer mark) {
			// String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
			// // 根据输送线plc遍历
			// for (DevpSlave devp : slaveProperties.getDevp()) {
			// // 遍历入库口
			// for (DevpSlave.Sta inSta : devp.getInSta()) {
			// // 获取条码扫描仪信息
			// BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			// SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			// StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			// StaProtocol staProtocolIn = devpThread.getStation().get(inSta.getStaNo() -1);
			// if (staProtocolIn == null) {
			// continue;
			// } else {
			// staProtocolIn = staProtocolIn.clone();
			// }
			// if (barcodeThread == null) {
			// continue;
			// }
			// String barcode = barcodeThread.getBarcode();
			// if(staProtocolIn.getStamp() == 1 && barcode!=null && !barcode.isEmpty()) {
			// log.error("生成任务中");
			//
			// WrkMast checkPick = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			// .eq("barcode", barcode)
			// .in("io_type", 107, 103, 57));
			// if (!Cools.isEmpty(checkPick)) {
			// continue;
			// }
			// try {
			// LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			//
			// SearchLocParam param = new SearchLocParam();
			// locTypeDto.setLocType1((short) 1);
			// param.setBarcode(barcode);
			// param.setIoType(1);
			// param.setSourceStaNo(inSta.getStaNo());
			// param.setLocType1(locTypeDto.getLocType1());
			// param.setWeight(staProtocol.getWeight());
			// String response = new HttpHandler.Builder()
			// .setTimeout(30, TimeUnit.SECONDS)
			// .setUri(wmsUrl)
			// .setPath("/rpc/pakin/loc/v1")
			// .setJson(JSON.toJSONString(param))
			// .build()
			// .doPost();
			// JSONObject jsonObject = JSON.parseObject(response);
			// if (jsonObject.getInteger("code").equals(200)) {
			// StartupDto dto = jsonObject.getObject("data", StartupDto.class);
			// barcodeThread.setBarcode("");
			// staProtocolIn.setWorkNo(dto.getWorkNo());
			//// //staProtocol.setStaNo(RouteUtils.SouStaEnd(dto.getStaNo(),dto.getSourceStaNo()));
			//// staProtocol.setStaNo(dto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocolIn.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocolIn));
			// log.error("工作号下发2：" + dto.getWorkNo() + "," + dto.getStaNo());
			// ledThread.errorReset();
			// log.error("组托请求后LED错误清除");
			// if (!result) {
			// News.error(methodName + ":更新plc站点信息失败");
			//
			// throw new CoolException("更新plc站点信息失败");
			// }
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			// }else{
			// if (staProtocol == null) {
			// continue;
			// } else {
			// staProtocol = staProtocol.clone();
			// }
			//
			// // 尺寸检测异常
			// 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.getWeight() > 1000) {
			// errMsg = "超重或未读取";
			// back = true;
			// }
			// if (!back && staProtocol.isBarcodeErr()) {
			// errMsg = "扫码失败";
			// back = true;
			// }
			//
			// // 退回
			// if (back) {
			// log.info("errmsg: " + errMsg);
			//// News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
			//
			// if (!staProtocol.isLoading()) {
			// continue;
			// }
			// if (!staProtocol.isPakMk()) {
			// continue;
			// }
			// staProtocol.setWorkNo(wrkNo);
			// News.info("{}PLC入库回退：{}，任务号：{}", inSta.getStaNo(), errMsg, wrkNo);
			// wrkNo++;
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发1：" + wrkNo + "," + inSta.getBackSta());
			// }
			//
			// // 判断是否满足入库条件
			// if (staProtocol.isAutoing()
			// && staProtocol.isLoading()
			// && staProtocol.isInEnable()
			// && !staProtocol.isEmptyMk()
			// && staProtocol.isPakMk()) {
			// if (Cools.isEmpty(barcode) \|\| "NG".endsWith(barcode) \|\| "NoRead".equals(barcode) \|\| "00000000".equals(barcode)) {
			// News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			//
			// staProtocol.setWorkNo(wrkNo);
			// News.info("{}barcode入库回退：{}，任务号：{}", inSta.getStaNo(), errMsg, wrkNo);
			// wrkNo++;
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发1：" + wrkNo + "," + inSta.getBackSta());
			// continue;
			// }
			// // 判断重复工作档
			// WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			// if (wrkMast != null) {
			// News.error(barcode + "条码已存在状态为（ 2.设备上走）的数据,请查看WCS输送线界面,工作号={}", wrkMast.getWrkNo());
			// continue;
			// }
			// WrkMast checkPick = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			// .eq("barcode", barcode)
			// .in("io_type", 107, 103, 57));
			// if (!Cools.isEmpty(checkPick)) {
			// continue;
			// }
			// try {
			// LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			//
			// SearchLocParam param = new SearchLocParam();
			// locTypeDto.setLocType1((short) 1);
			// param.setBarcode(barcode);
			// param.setIoType(1);
			// param.setSourceStaNo(inSta.getStaNo());
			// param.setLocType1(locTypeDto.getLocType1());
			// param.setWeight(staProtocol.getWeight());
			// String response = new HttpHandler.Builder()
			// .setTimeout(30,TimeUnit.SECONDS)
			// .setUri(wmsUrl)
			// .setPath("/rpc/pakin/loc/v1")
			// .setJson(JSON.toJSONString(param))
			// .build()
			// .doPost();
			// JSONObject jsonObject = JSON.parseObject(response);
			// if (jsonObject.getInteger("code").equals(200)) {
			// StartupDto dto = jsonObject.getObject("data", StartupDto.class);
			// barcodeThread.setBarcode("");
			// staProtocol.setWorkNo(dto.getWorkNo());
			// //staProtocol.setStaNo(RouteUtils.SouStaEnd(dto.getStaNo(),dto.getSourceStaNo()));
			// staProtocol.setStaNo(dto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发2：" + dto.getWorkNo() + "," + dto.getStaNo());
			//
			// ledThread.errorReset();
			// log.error("组托请求后LED错误清除");
			//
			// if (!result) {
			// News.error(methodName + ":更新plc站点信息失败");
			//
			// throw new CoolException("更新plc站点信息失败");
			// }
			// } else {
			// if (jsonObject.getString("msg").equals("工作档已存在")) {
			// continue;
			// }
			// staProtocol.setWorkNo(wrkNo);
			// wrkNo++;
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发2：" + staProtocol.getWorkNo() + "," + staProtocol.getStaNo());
			//
			// String errorMsg = jsonObject.getString("msg");
			// if (!Cools.isEmpty(errorMsg)) {
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			// }
			// }
			//
			// } catch (Exception e) {
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			//
			// }
			// }
			// }
			// }
			//
			// }

			// 静态线程安全Set，用于存储正在调用接口的工位号
			private static final Set<Integer> callingStations = ConcurrentHashMap.newKeySet();

			public synchronized void generateStoreWrkFile(Integer mark) {
			String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
			final Set<String> INVALID_BARCODES = new HashSet<>(Arrays.asList("NG", "NoRead", "00000000"));

			for (DevpSlave devp : slaveProperties.getDevp()) {
			for (DevpSlave.Sta inSta : devp.getInSta()) {

			// 【判断工位是否正在调用接口，跳过正在调用的】
			int staNo = inSta.getStaNo();
			if (!callingStations.add(staNo)) {
			// 如果已存在调用中，跳过
			log.info("工位{}接口调用中，跳过本次", staNo);
			continue;
			}

			try {
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());

			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			StaProtocol staProtocolIn = devpThread.getStation().get(staNo - 1);

			if (staProtocolIn == null \|\| barcodeThread == null) continue;
			staProtocolIn = staProtocolIn.clone();
			String barcode = barcodeThread.getBarcode();

			// 如果前工位有货 + 扫码器有条码
			if (staProtocolIn.getStamp() == 1 && !barcode.equals("00000000") && !barcode.isEmpty()) {
			log.info("生成信号时间: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));
			if (wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("barcode", barcode)
			.in("io_type", 107, 103, 57)) != null) {
			continue;
			}

			try {


			SearchLocParam param = new SearchLocParam();
			param.setBarcode(barcode);
			param.setIoType(1);
			param.setSourceStaNo(staNo);
			param.setLocType1((short) 1);
			param.setWeight(staProtocol.getWeight());

			String response = new HttpHandler.Builder()
			.setTimeout(30, TimeUnit.SECONDS)
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			.setJson(JSON.toJSONString(param))
			.build()
			.doPost();

			JSONObject json = JSON.parseObject(response);
			if (json.getInteger("code").equals(200)) {
			StartupDto dto = json.getObject("data", StartupDto.class);
			barcodeThread.setBarcode("");
			staProtocolIn.setWorkNo(dto.getWorkNo());
			devpThread.setPakMk(staProtocolIn.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocolIn));
			log.info("生成任务时间: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));

			ledThread.errorReset();
			log.error("工作号下发2：" + dto.getWorkNo() + "," + dto.getStaNo());

			if (!result) {
			News.error(methodName + ":更新plc站点信息失败");
			throw new CoolException("更新plc站点信息失败");
			}
			} else {
			String msg = json.getString("msg");
			if (!"工作档已存在".equals(msg) && staProtocol.getWorkNo()<9999) {
			staProtocol.setWorkNo(wrkNo++);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			log.error("输送线下发2：" + staProtocol.getWorkNo() + "," + staProtocol.getStaNo());
			if (!Cools.isEmpty(msg)) {
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, msg));
			}
			}
			}
			} catch (Exception e) {
			log.error("组托任务异常：", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}

			continue;
			} else {
			// 尺寸/重量/扫码异常检测
			if (staProtocol == null) continue;
			staProtocol = staProtocol.clone();
			boolean back = false;
			String errMsg = "";

			if (staProtocol.isFrontErr()) { errMsg = "前超限"; back = true; }
			else if (staProtocol.isBackErr()) { errMsg = "后超限"; back = true; }
			else if (staProtocol.isHighErr()) { errMsg = "高超限"; back = true; }
			else if (staProtocol.isLeftErr()) { errMsg = "左超限"; back = true; }
			else if (staProtocol.isRightErr()) { errMsg = "右超限"; back = true; }
			else if (staProtocol.getWeight() > 1000) { errMsg = "超重或未读取"; back = true; }
			else if (staProtocol.isBarcodeErr()) { errMsg = "扫码失败"; back = true; }

			// 尺寸异常回退
			if (back && staProtocol.getWorkNo() <9999) {
			// log.info("errmsg: " + errMsg);
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));

			if (!staProtocol.isLoading() \|\| !staProtocol.isPakMk()) continue;
			staProtocol.setWorkNo(wrkNo++);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			log.error("输送线下发1：" + wrkNo + "," + inSta.getBackSta());
			continue;
			}

			// // 入库条件满足，开始请求入库地址
			// if (staProtocol.isAutoing() && staProtocol.isLoading()
			// && staProtocol.isInEnable() && !staProtocol.isEmptyMk() && staProtocol.isPakMk()) {
			//
			// if (Cools.isEmpty(barcode) \|\| INVALID_BARCODES.contains(barcode)) {
			// News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			// staProtocol.setWorkNo(wrkNo++);
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发1：{} , {}", wrkNo, inSta.getBackSta());
			// continue;
			// }
			//
			// if (wrkMastMapper.selectPakInStep1(staNo, barcode) != null \|\|
			// wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			// .eq("barcode", barcode)
			// .in("io_type", 107, 103, 57)) != null) {
			// News.error(barcode + "条码已存在状态为（2.设备上走）的数据，请查看WCS输送线界面");
			// continue;
			// }
			//
			// try {
			// SearchLocParam param = new SearchLocParam();
			// param.setBarcode(barcode);
			// param.setIoType(1);
			// param.setSourceStaNo(staNo);
			// param.setLocType1((short) 1);
			// param.setWeight(staProtocol.getWeight());
			//
			// String response = new HttpHandler.Builder()
			// .setTimeout(30, TimeUnit.SECONDS)
			// .setUri(wmsUrl)
			// .setPath("/rpc/pakin/loc/v1")
			// .setJson(JSON.toJSONString(param))
			// .build()
			// .doPost();
			//
			// JSONObject json = JSON.parseObject(response);
			// if (json.getInteger("code").equals(200)) {
			// StartupDto dto = json.getObject("data", StartupDto.class);
			// barcodeThread.setBarcode("");
			// staProtocol.setWorkNo(dto.getWorkNo());
			// staProtocol.setStaNo(dto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// ledThread.errorReset();
			// log.error("输送线下发2：" + dto.getWorkNo() + "," + dto.getStaNo());
			//
			// if (!result) {
			// News.error(methodName + ":更新plc站点信息失败");
			// throw new CoolException("更新plc站点信息失败");
			// }
			// } else {
			// String msg = json.getString("msg");
			// if (!"工作档已存在".equals(msg)) {
			// staProtocol.setWorkNo(wrkNo++);
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// log.error("输送线下发2：" + staProtocol.getWorkNo() + "," + staProtocol.getStaNo());
			// if (!Cools.isEmpty(msg)) {
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, msg));
			// }
			// }
			// }
			// } catch (Exception e) {
			// log.error("组托任务异常：", e);
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			// }
			}
			} finally {
			// 【无论接口调用是否成功，最后都释放调用标记】
			callingStations.remove(staNo);
			log.debug("工位{}接口调用完成，释放调用标记", staNo);
			}
			}
			}
			}


			/**
			* wms入库
			@@ -922,7 +1344,7 @@
			if (crnProtocol.getLastIo().equals("I")) {
			if (basCrnp.getInEnable().equals("Y")) {
			//mark - 1 - ....
			this.crnStnToLoc(crn, crnProtocol, mark); // 入库
			this.crnStnToLoc(crn, crnProtocol, mark, crnThread); // 入库
			crnProtocol.setLastIo("O");
			} else if (basCrnp.getOutEnable().equals("Y")) {
			//mark - 2 - ....
			@@ -936,7 +1358,7 @@
			this.locToCrnStn(crn, crnProtocol, mark); // 出库
			crnProtocol.setLastIo("I");
			} else if (basCrnp.getInEnable().equals("Y")) {
			this.crnStnToLoc(crn, crnProtocol, mark); // 入库
			this.crnStnToLoc(crn, crnProtocol, mark, crnThread); // 入库
			crnProtocol.setLastIo("O");
			}
			}
			@@ -944,7 +1366,7 @@
			// 库位移转
			//mark - 3 - ....
			this.locToLoc(crn, crnProtocol, mark);
			this.crnRebackHp(crnProtocol, crnThread);
			this.crnRebackHp(crnProtocol, crnThread,null);

			}
			// News.infoNoLog(""+mark+" - 0"+" - 堆垛机入出库作业下发执行完成");
			@@ -953,39 +1375,34 @@
			/**
			* 回原点，堆垛机没有执行中任务，设备存在入库任务时叫回原点
			*/
			public synchronized void crnRebackHp(CrnProtocol crnProtocol, CrnThread crnThread) {
			// for (CrnSlave crn : slaveProperties.getCrn()) {
			// // 获取堆垛机信息
			// CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			// CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			// if (crnProtocol == null) {
			// continue;
			// }
			// BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			// if (basCrnp == null) {
			// log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			// continue;
			// }
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			if (crnProtocol.getBay() == 121) {
			return;
			}
			public synchronized void crnRebackHp(CrnProtocol crnProtocol, CrnThread crnThread,String staNo) {
			if(staNo == null){
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			if (crnProtocol.getBay() == 121 \|\| crnProtocol.getBay() == 1) {
			return;
			}
			int x=1;
			switch (crnProtocol.getCrnNo()){
			case 1: x =1; break;
			case 2: x =3; break;
			case 3: x =5; break;
			case 4: x =7; break;
			}

			// 已经存在吊车执行任务时，则过滤3,12
			if (wrkMastMapper.selectWorking(crnProtocol.getCrnNo()) != null) {
			return;
			}
			// 已经存在吊车执行任务时，则过滤3,12
			if (wrkMastMapper.selectWorking(crnProtocol.getCrnNo()) != null) {
			return;
			}

			//堆垛机有执行中任务，过滤3,4,11,12
			if (wrkMastMapper.selectCrnWorking(crnProtocol.getCrnNo()) != null) {
			return;
			}
			//堆垛机有执行中任务，过滤3,4,11,12
			if (wrkMastMapper.selectCrnWorking(crnProtocol.getCrnNo()) != null) {
			return;
			}

			//输送线没有入库任务，过滤2
			if (wrkMastMapper.selectDevWorking(crnProtocol.getCrnNo()) == null) {
			return;
			}
			if(crnProtocol.getCrnNo() == 1){
			//输送线没有入库任务，过滤2
			if (wrkMastMapper.selectDevWorking(crnProtocol.getCrnNo()) != null) {
			return;
			}
			News.info("堆垛机召回原点==>>" + crnProtocol.getCrnNo() + "号堆垛机有入库任务,召回原点");
			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			@@ -993,9 +1410,9 @@
			crnCommand.setTaskNo((short) 9999); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.X_MOVE); // 任务模式: 回原点
			crnCommand.setSourcePosX((short) 1); // 源库位排
			crnCommand.setSourcePosX((short) x); // 源库位排
			crnCommand.setSourcePosY((short) 121); // 源库位列
			crnCommand.setSourcePosZ((short) 1); // 源库位层
			crnCommand.setSourcePosZ((short) 2); // 源库位层
			crnCommand.setDestinationPosX((short) 0); // 目标库位排
			crnCommand.setDestinationPosY((short) 0); // 目标库位列
			crnCommand.setDestinationPosZ((short) 0); // 目标库位层
			@@ -1004,7 +1421,57 @@
			}
			crnThread.setBackHpFlag(true);
			}
			} else {
			int y = 1; // 默认列
			int x=1;
			switch (crnProtocol.getCrnNo()){
			case 1: x =1; break;
			case 2: x =3; break;
			case 3: x =5; break;
			case 4: x =7; break;
			}
			int staNoInt = Integer.parseInt(staNo);

			int z = staNoInt / 100; // 层

			if ((staNoInt >= 121 && staNoInt <= 126) \|\| (staNoInt >= 221 && staNoInt <= 231) \|\| (staNoInt >= 411 && staNoInt <= 414)) {
			y = 121;
			}

			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			if (crnProtocol.getBay() == y) {
			return;
			}

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

			// 堆垛机有执行中任务
			if (wrkMastMapper.selectCrnWorking(crnProtocol.getCrnNo()) != null) {
			return;
			}


			News.info("堆垛机召回原点==>>" + crnProtocol.getCrnNo() + "号堆垛机有入库任务,召回原点");
			// 命令下发
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(crnProtocol.getCrnNo());
			crnCommand.setTaskNo((short) 9999);
			crnCommand.setAckFinish((short) 0);
			crnCommand.setTaskMode(CrnTaskModeType.X_MOVE);
			crnCommand.setSourcePosX((short) x); // 默认排始终为1
			crnCommand.setSourcePosY((short) y); // 动态列
			crnCommand.setSourcePosZ((short) z); // 动态层
			crnCommand.setDestinationPosX((short) 0);
			crnCommand.setDestinationPosY((short) 0);
			crnCommand.setDestinationPosZ((short) 0);
			if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) {
			News.error("堆垛机回原点命令下发失败，堆垛机号={}，任务数据={}", crnProtocol.getCrnNo(), JSON.toJSON(crnCommand));
			}
			crnThread.setBackHpFlag(true);
			}
			}
			// }
			}
			@@ -1012,7 +1479,7 @@
			/**
			* 入库 ===>> 堆垛机站到库位
			*/
			public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol, Integer mark) {
			public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol, Integer mark,CrnThread crnThread) {
			News.warnNoLog("" + mark + " - 1" + " - 0" + " - 堆垛机入出库作业下发：执行入库");
			for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
			boolean flag = false;
			@@ -1031,11 +1498,23 @@
			News.error("" + mark + " - 1" + " - 2" + " - 入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}
			// if(staProtocol.getWorkNo() == 9998){
			// continue;
			WrkMast wrkMast1 = wrkMastMapper.selectPakInOne(slave.getId());
			if(wrkMast1 != null){
			crnRebackHp(crnProtocol,crnThread,wrkMast1.getStaNo().toString());
			}
			// if(staProtocol.getSiteId() == 225){
			// News.info("入库站点信息{}",staProtocol);
			// staProtocol.isLoading() &&
			// }
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
			if(staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() <9998){
			log.info("读取到工作号时间: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));

			}
			// && staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() <9998
			if (staProtocol.isAutoing() && staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() <9998
			&& staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
			log.info("任务满足下发时间: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));

			flag = true;
			}
			if (!flag) {
			@@ -1046,8 +1525,10 @@
			continue;
			}
			// 获取工作状态为2（设备上走）的入库工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
			WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo(), crnStn.getStaNo());
			// wrkMast = wrkMast1;
			if (null == wrkMast) {
			log.info("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
			News.infoNoLog("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
			// log.error("查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
			continue;
			@@ -1074,48 +1555,6 @@
			continue;
			}

			// // 双深库位且浅库位有货，则需先对浅库位进行库位移转
			// if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) {
			// News.warnNoLog("" + mark + " - 1" + " - 8" + " - 双深库位且浅库位有货，则需先对浅库位进行库位移转 : 开始执行任务号={}", wrkMast.getWrkNo());
			// 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")) {
			// News.warnNoLog("" + mark + " - 1" + " - 9" + " - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！库位状态={}", shallowLoc.getLocSts());
			// WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			// if (null == waitWrkMast) {
			// News.error("" + mark + " - 1" + " - 10" + " - {}库位异常，未检索到相应工作档！", shallowLocNo);
			// } else {
			// waitWrkMast.setIoPri(15D);
			// waitWrkMast.setModiTime(new Date());
			// if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			// News.error("" + mark + " - 1" + " - 11" + " - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			// }
			// continue;
			// }
			//
			// } else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			// News.warnNoLog("" + mark + " - 1" + " - 12" + " - // F、D 库位状态={}", shallowLoc.getLocSts());
			// // 此标记避免多次执行移库任务
			// if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())) {
			// wrkMast.setUpdMk("Y");
			// wrkMast.setIoPri(14D);
			// wrkMastMapper.updateById(wrkMast);
			// // 生成工作档,将浅库位移转到新的库位中
			// moveLocForDeepLoc(slave, shallowLoc, mark);
			// // 生成工作档、改变浅库位的源库/目标库库位状态、下发堆垛机命令（立马执行)
			//// moveLocForDeepLocPakin(slave, shallowLoc, wrkMast);
			// }
			// continue;
			// } else if (shallowLoc.getLocSts().equals("Q")) {
			// News.warnNoLog("" + mark + " - 1" + " - 13" + " - // Q 库位状态={}", shallowLoc.getLocSts());
			// WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			// if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
			// News.infoNoLog("" + mark + " - 1" + " - 14" + " - // F、D 工作状态(判断条件为==4)={}", waitWrkMast.getWrkSts());
			// continue;
			// }
			// }
			// }
			News.warnNoLog("" + mark + " - 1" + " - 15" + " - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}", wrkMast.getWrkNo().shortValue()
			, crnStn.getRow().shortValue(), crnStn.getBay().shortValue(), crnStn.getLev().shortValue()
			, locMast.getRow1().shortValue(), locMast.getBay1().shortValue(), locMast.getLev1().shortValue());
			@@ -1133,21 +1572,12 @@
			crnCommand.setDestinationPosY((short) (locMast.getBay1() + slave.getOffset())); // 目标库位列
			crnCommand.setDestinationPosZ((short) (locMast.getLev1() + slave.getOffset())); // 目标库位层
			// crnCommand.setTraySize(locMast.getLocType1() == 2);
			log.info("堆垛机任务下发时间: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));

			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.error("" + mark + " - 1" + " - 16" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {

			// long startTime = System.currentTimeMillis();
			// while ((System.currentTimeMillis() - startTime) < COMMAND_TIMEOUT) {
			//
			// if (true) {
			// break;
			// }
			//
			// try{
			// Thread.sleep(500);
			// }catch(Exception ignore){}
			// }

			// 修改工作档状态 2.设备上走 => 3.吊车入库中
			Date now = new Date();
			@@ -1212,11 +1642,21 @@
			break;
			// continue;
			}
			// && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
			// && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()
			boolean canOut;
			Config config = configService.selectConfigByCode("C-OUT-OP");

			if (Cools.isEmpty(config) \|\| config.getValue().equals("false") ){
			canOut = staProtocol.isAutoing()
			&& !staProtocol.isLoading()
			&& "Y".equals(staDetl.getCanouting())
			&& staProtocol.getWorkNo() == 0
			&& staProtocol.isOutEnable();
			} else {
			canOut = staProtocol.isAutoing();
			}

			// 判断堆垛机出库站状态
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
			&& staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
			if (canOut) {
			// 命令下发区 --------------------------------------------------------------------------

			// 堆垛机控制过滤
			@@ -1531,9 +1971,9 @@



			// 堆垛机复位
			News.warnNoLog("" + mark + " - 2" + " - 修改成功后复位堆垛机 : 堆垛机号={}", crnThread.getCrnProtocol().getCrnNo());
			crnThread.setResetFlag(true);
			// 堆垛机复位
			News.warnNoLog("" + mark + " - 2" + " - 修改成功后复位堆垛机 : 堆垛机号={}", crnThread.getCrnProtocol().getCrnNo());
			crnThread.setResetFlag(true);
			}
			}else{
			// 状态：等待确认并且任务完成位 = 1