zy-wcs.git - Gitblit

			@@ -24,21 +24,22 @@
			import com.zy.common.utils.News;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.RgvThread;
			import com.zy.core.cache.MessageQueue;
			import com.zy.core.cache.SlaveConnection;
			import com.zy.core.enums.*;
			import com.zy.core.model.CrnSlave;
			import com.zy.core.model.DevpSlave;
			import com.zy.core.model.LedSlave;
			import com.zy.core.model.Task;
			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.RgvCommand;
			import com.zy.core.model.protocol.CrnProtocol;
			import com.zy.core.model.protocol.RgvProtocol;
			import com.zy.core.model.protocol.StaProtocol;
			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.ZyRgvThread;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			@@ -46,10 +47,8 @@
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;

			import java.util.ArrayList;
			import java.util.Date;
			import java.util.List;
			import java.util.Set;
			import java.io.IOException;
			import java.util.*;
			import java.util.stream.Collectors;

			/**
			@@ -70,6 +69,8 @@
			@Autowired
			private WrkMastMapper wrkMastMapper;
			@Autowired
			private WrkMastService wrkMastService;
			@Autowired
			private WrkDetlService wrkDetlService;
			@Autowired
			private WaitPakinMapper waitPakinMapper;
			@@ -87,9 +88,21 @@
			private BasErrLogService basErrLogService;
			@Autowired
			private BasCrnErrorMapper basCrnErrorMapper;
			@Autowired
			private EmptyBarrelInService emptyBarrelInService;
			@Autowired
			private WrkMastStaService wrkMastStaService;
			@Autowired
			private MatnrCodeService matnrCodeService;
			@Autowired
			private WaitPakinService waitPakinService;
			@Autowired
			private MatService matService;

			@Value("${wms.url}")
			private String wmsUrl;

			public int workNo = 9900;

			/**
			* 组托
			@@ -107,12 +120,56 @@
			}
			String barcode = barcodeThread.getBarcode();

			////判断101和104是否是拣料、并板、盘点再入库
			//WrkMast wrkMast1=wrkMastMapper.selectpj(inSta.getStaNo(),barcode);
			//if((inSta.getStaNo().equals(101) \|\| inSta.getStaNo().equals(104)) &&!Cools.isEmpty(barcode)&&!Cools.isEmpty(wrkMast1)){
			// log.error("101或104拣料、并板、盘点再入库", wrkMast1.getWrkNo());
			// continue;
			//}


			// 获取入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			// 尺寸检测异常
			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 (!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			@@ -128,42 +185,31 @@
			// }
			continue;
			}

			// 获取入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// 入出库模式判断
			if (inSta.getStaNo() == 101 && devpThread.ioModeOf1F1 == IoModeType.PAKOUT_MODE) {
			continue;
			}
			if (inSta.getStaNo() == 104 && devpThread.ioModeOf1F2 == IoModeType.PAKOUT_MODE) {
			continue;
			}

			// 判断是否满足入库条件
			if (staProtocol.isAutoing() && staProtocol.isLoading()
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getWorkNo() > 9990)
			&& staProtocol.isPakMk()) {// && !Cools.isEmpty(barcode)) {
			&& !staProtocol.isEmptyMk()
			&& (staProtocol.getWorkNo() == 0 \|\| staProtocol.getWorkNo() > 9990)
			&& staProtocol.isPakMk()) {

			// if(Cools.isEmpty(barcode) \|\| "NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			// log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			// //条码为空或者不符合，退库到172站点
			if(Cools.isEmpty(barcode) \|\| "NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			//条码为空或者不符合，退库到
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			String errorMsg = "扫码失败，请重试";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			// staProtocol.setWorkNo((short)9999);
			// staProtocol.setStaNo((short)172);
			// staProtocol.setStaNo((short)(staProtocol.getStaNo()-1));
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败");
			// }
			// continue;
			// }
			continue;
			}

			// 判断重复工作档
			WrkMast wrkMast = new WrkMast();
			@@ -174,8 +220,7 @@
			continue;
			}
			}

			// // 获取入库通知档
			// 获取入库通知档
			// List<WaitPakin> waitPakins = waitPakinMapper.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", barcode).eq("io_status", "N"));
			// if (waitPakins.isEmpty()) {
			// log.error("无此入库条码数据。条码号={}", barcode);
			@@ -183,15 +228,12 @@
			// }

			try {

			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

			SearchLocParam param = new SearchLocParam();
			param.setBarcode(barcode);
			param.setIoType(1);
			param.setSourceStaNo(inSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			param.setFull(staProtocol.isFull());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			@@ -200,7 +242,6 @@
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			// Integer code = jsonObject.getInteger("code");
			if (jsonObject.getInteger("code").equals(200)) {
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			@@ -213,109 +254,276 @@
			if (!result) {
			throw new CoolException("更新plc站点信息失败");
			}
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}
			// if (jsonObject.getInteger("code").equals(200)) {
			// StartupDto dto = jsonObject.getObject("data", StartupDto.class);
			//
			// barcodeThread.setBarcode("");
			// staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			// staProtocol.setStaNo(dto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			//
			// ledThread.errorReset();
			//
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败");
			// }
			// } else if(code == 500){
			// if (ledThread != null) {
			// String errorMsg = jsonObject.getString("msg");
			// if (!Cools.isEmpty(errorMsg)) {
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			// }
			// }
			// log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			// } else if (code == 700) {
			// staProtocol.setWorkNo((short) 9995);
			} else if(jsonObject.getInteger("code").equals(700)) {
			// staProtocol.setWorkNo((short) 9999);
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			//
			// // led 异常显示
			// if (ledThread != null) {
			// String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			// }
			// }


			// // 检索库位
			// LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			// List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
			// StartupDto startupDto = commonService.getLocNo(1, 1, inSta.getStaNo(), matNos, locTypeDto, 0);
			// // 工作号
			// int workNo = startupDto.getWorkNo();
			// // 插入工作明细档
			// wrkDetlService.createWorkDetail(workNo, waitPakins, barcode);
			//
			// // 插入工作主档
			// wrkMast = new WrkMast();
			// wrkMast.setWrkNo(workNo);
			// wrkMast.setIoTime(new Date());
			// wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
			// wrkMast.setIoType(1); // 入出库状态：1.入库
			// wrkMast.setIoPri(10D); // 优先级：10
			// wrkMast.setCrnNo(startupDto.getCrnNo());
			// wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
			// wrkMast.setStaNo(startupDto.getStaNo());
			// wrkMast.setLocNo(startupDto.getLocNo());
			// wrkMast.setBarcode(barcode); // 托盘码
			// wrkMast.setFullPlt("Y"); // 满板：Y
			// wrkMast.setPicking("N"); // 拣料
			// wrkMast.setExitMk("N"); // 退出
			// wrkMast.setEmptyMk("N"); // 空板
			// wrkMast.setLinkMis("N");
			// // 操作人员数据
			// wrkMast.setAppeTime(new Date());
			// wrkMast.setModiTime(new Date());
			// Integer insert = wrkMastMapper.insert(wrkMast);
			// if (insert == 0) {
			// throw new CoolException("保存工作档失败");
			// }
			// // 更新目标库位状态
			// LocMast locMast = locMastService.selectById(startupDto.getLocNo());
			// locMast.setLocSts("S"); // S.入库预约
			// locMast.setModiTime(new Date());
			// if (!locMastService.updateById(locMast)){
			// throw new CoolException("改变库位状态失败");
			// }
			// // 将入库通知档修改为已启动
			// if (wrkMastMapper.updateWaitPakInStep1(barcode) == 0) {
			// throw new CoolException("修改入库通知档状态为已启动失败");
			// }
			//
			// // 命令下发区 --------------------------------------------------------------------------
			//
			// // 更新站点信息且下发plc命令
			// barcodeThread.setBarcode("");
			// staProtocol.setWorkNo((short) workNo);
			// staProtocol.setStaNo(startupDto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败");
			// }
			log.error(barcode + "托盘识别异常，请先进行组托！");
			// led 异常显示
			ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}

			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}

			}

			}
			}

			}
			public synchronized void generateStoreWrkFile7() {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历入库口
			for (DevpSlave.Sta inSta : devp.getInSta7()) {

			// 获取入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

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

			// 尺寸检测异常
			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.isBan()){

			// 退回
			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.getStaNoEnd() != 2001){
			log.error(staProtocol.getStaNo()+"站点，空桶，非法目标站！！！！！！"+staProtocol.getStaNoEnd().toString());
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk()
			&& (staProtocol.getWorkNo() == 0 \|\| staProtocol.getWorkNo() > 9990)
			&& staProtocol.isPakMk()) {
			Integer workNo1 = commonService.getWorkNo(3);
			Date now = new Date();
			// 保存工作档
			WrkMast wrkMast = new WrkMast();
			wrkMast.setWrkNo(workNo1);
			wrkMast.setIoTime(now);
			wrkMast.setWrkSts(101L); // 工作状态：101.初始
			wrkMast.setIoType(199); // 入出库状态： 199.转移
			wrkMast.setIoPri(15D);
			wrkMast.setCrnNo(0);
			wrkMast.setSourceStaNo(staProtocol.getStaNo().intValue()); // 源站
			wrkMast.setStaNo(staProtocol.getStaNoEnd().intValue()); // 目标站
			wrkMast.setFullPlt("N"); // 满板
			wrkMast.setPicking("N"); // 拣料
			wrkMast.setExitMk("N"); // 退出
			wrkMast.setEmptyMk("Y"); // 空板
			wrkMast.setBarcode("KB888888"); // 托盘码
			wrkMast.setLinkMis("N");
			wrkMast.setCtnNo("Y"); // 入库阻塞库位移转标记
			wrkMast.setAppeTime(now);
			wrkMast.setModiTime(now);
			int res = wrkMastMapper.insert(wrkMast);
			if (res == 0) {
			// throw new CoolException("");
			log.error(staProtocol.getStaNo()+"站点，空桶，保存工作档主档失败！！！！！！"+now.toString());
			continue;
			}
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());

			// StaProtocol staProtocol1 = new StaProtocol();
			staProtocol.setWorkNo(workNo1.shortValue());
			staProtocol.setStaNo((short)3001);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			ledThread.errorReset();
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败");
			}
			}

			continue;
			}

			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 (!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if ("NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			continue;
			}
			} else {
			// led 异常显示
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			// if (ledThread != null) {
			// String errorMsg = "扫码失败，请重试";
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			// }
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk()
			&& (staProtocol.getWorkNo() == 0 \|\| staProtocol.getWorkNo() > 9990)
			&& staProtocol.isPakMk()) {

			if(Cools.isEmpty(barcode) \|\| "NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			//条码为空或者不符合，退库到
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			String errorMsg = "扫码失败，请重试";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			// staProtocol.setWorkNo((short)9999);
			// staProtocol.setStaNo((short)(staProtocol.getStaNo()-1));
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败");
			// }
			continue;
			}

			// 判断重复工作档
			WrkMast wrkMast = new WrkMast();
			if (barcode.length() == 8) {
			wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			if (wrkMast != null) {
			log.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			continue;
			}
			}
			// 获取入库通知档
			// List<WaitPakin> waitPakins = waitPakinMapper.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", barcode).eq("io_status", "N"));
			// if (waitPakins.isEmpty()) {
			// log.error("无此入库条码数据。条码号={}", barcode);
			// continue;
			// }

			try {
			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			SearchLocParam param = new SearchLocParam();
			param.setBarcode(barcode);
			param.setIoType(1);
			param.setSourceStaNo(inSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			.setJson(JSON.toJSONString(param))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (jsonObject.getInteger("code").equals(200)) {
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			barcodeThread.setBarcode("");
			staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			staProtocol.setStaNo(dto.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			ledThread.errorReset();
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败");
			}
			} else if(jsonObject.getInteger("code").equals(700)) {
			// staProtocol.setWorkNo((short) 9999);
			// staProtocol.setStaNo(inSta.getBackSta().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// // led 异常显示
			// if (ledThread != null) {
			// String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			// }
			log.error(barcode + "托盘识别异常，请先进行组托！");
			// led 异常显示
			ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}

			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}

			}
			}
			@@ -393,18 +601,16 @@
			for (DevpSlave.Sta pickSta : devp.getPickSta()) {
			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());

			if (barcodeThread == null) {
			continue;
			}
			String barcode = barcodeThread.getBarcode();



			if (!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
			} else {
			continue;
			if ("NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			continue;
			}
			}

			// 获取拣料入库站信息
			@@ -417,20 +623,38 @@
			}


			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& staProtocol.isPakMk()
			&& staProtocol.getWorkNo() == 9999) {
			// WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
			WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo().intValue());
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			if (barcode.equals("") \|\| barcode.equals("99999999")) {
			Integer led = pickSta.getLed();
			if (ledThread != null) {
			String errorMsg = "扫码异常，请重新入库！";
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			// // 更新站点信息且下发plc命令
			staProtocol.setWorkNo((short)9999);
			staProtocol.setStaNo((short)(staProtocol.getStaNo()-1));
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}
			continue;
			}

			// WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo().intValue());
			WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", barcode));

			if (wrkMast == null) {
			wrkMast = wrkMastMapper.selectPickStep(barcode);
			}
			if (wrkMast == null) {
			// 无拣料数据

			if (ledThread != null) {
			String errorMsg = "暂无拣料信息！！！";
			MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
			}
			continue;
			}
			if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
			@@ -509,6 +733,8 @@
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}else {
			ledThread.errorReset();
			}

			}
			@@ -523,6 +749,9 @@
			*/
			public synchronized void crnStnToOutStn() {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			if (crnSlave.getId() ==5){
			continue;
			}
			// 遍历堆垛机出库站
			for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
			// 获取堆垛机出库站信息
			@@ -554,18 +783,26 @@
			if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
			&& crnProtocol.statusType == CrnStatusType.WAITING
			&& crnProtocol.forkPosType == CrnForkPosType.HOME) {
			log.error("堆垛机等待确认！！！ [工作号:{}]", crnProtocol.getTaskNo());

			// 命令下发区 --------------------------------------------------------------------------

			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			if (crnProtocol.getCrnNo() !=5){
			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			}

			// 更新工作档状态为14失败
			wrkMast.setWrkSts(14L);

			if (crnStn.getStaNo() > 1013) {
			// 更新工作档状态为13.RGV搬运中
			wrkMast.setWrkSts(13L);
			}else {
			// 更新工作档状态为14
			wrkMast.setWrkSts(14L);
			}
			wrkMast.setCrnEndTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) != 0) {
			// 复位堆垛机
			@@ -586,6 +823,9 @@
			*/
			public synchronized void crnIoExecute() {
			for (CrnSlave crn : slaveProperties.getCrn()) {
			if (crn.getId() == 5){
			continue;
			}
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			@@ -609,6 +849,9 @@
			// 如果最近一次是入库模式
			if (crnProtocol.getLastIo().equals("I")) {
			if (basCrnp.getInEnable().equals("Y")) {
			if (crn.getId() == 5){
			continue;
			}
			this.crnStnToLoc(crn, crnProtocol); // 入库
			crnProtocol.setLastIo("O");
			} else if (basCrnp.getOutEnable().equals("Y")) {
			@@ -622,6 +865,10 @@
			this.locToCrnStn(crn, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			} else if (basCrnp.getInEnable().equals("Y")) {
			if (crn.getId() == 5){
			continue;
			}

			this.crnStnToLoc(crn, crnProtocol); // 入库
			crnProtocol.setLastIo("O");
			}
			@@ -834,10 +1081,10 @@
			// WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
			List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo());
			// 获取工作状态为14的工作档
			WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep14(slave.getId(), crnStn.getStaNo());
			if ( wrkMast1 !=null) {
			continue;
			}
			// WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep14(slave.getId(), crnStn.getStaNo());
			// if ( wrkMast1 !=null) {
			// continue;
			// }
			for (WrkMast wrkMast : wrkMasts) {
			if (wrkMast == null) {
			continue;
			@@ -861,14 +1108,6 @@
			// continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// // 入出库模式判断
			if (wrkMast.getStaNo() == 100 && devpThread.ioModeOf1F1 != IoModeType.PAKOUT_MODE) {
			continue;
			}
			if (wrkMast.getStaNo() == 103 && devpThread.ioModeOf1F2 != IoModeType.PAKOUT_MODE) {
			continue;
			}

			// 查询站点详细信息
			@@ -895,7 +1134,7 @@
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
			if (null == waitWrkMast) {
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			@@ -926,7 +1165,7 @@
			log.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo);
			continue;
			} else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
			if (null != waitWrkMast && (waitWrkMast.getWrkSts() == 4 \|\| waitWrkMast.getWrkSts() == 5)) {
			continue;
			}
			@@ -1170,6 +1409,7 @@
			}
			// 状态：等待确认并且任务完成位 = 1
			if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
			log.error("堆垛机处于等待确认且任务完成状态。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			if (crnProtocol.getTaskNo() == 9999) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			@@ -1331,6 +1571,7 @@
			// 获取空板入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(emptyInSta.getStaNo());
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());
			if (staProtocol == null) {
			continue;
			} else {
			@@ -1339,9 +1580,16 @@

			// 站点条件判断
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
			&& staProtocol.isEmptyMk() && (staProtocol.getWorkNo() >= 9990
			&& staProtocol.getWorkNo() <= 9999) && staProtocol.isPakMk()) {

			&& (staProtocol.isEmptyMk() \|\| staProtocol.getStaNo() == 9999)
			// && (staProtocol.getWorkNo() >= 9990 && staProtocol.getWorkNo() <= 9999)
			&& staProtocol.isPakMk()) {
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
			.eq("sta_no", emptyInSta.getStaNo())
			.eq("io_type", 10)
			.eq("wrk_sts", 2));
			if (!Cools.isEmpty(wrkMasts)){
			continue;
			}
			try {
			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

			@@ -1358,7 +1606,7 @@
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			ledThread.errorReset();
			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			staProtocol.setStaNo(dto.getStaNo().shortValue());
			@@ -1374,60 +1622,6 @@
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}


			// // 检索库位
			// LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			// StartupDto startupDto = commonService.getLocNo(1, 10, emptyInSta.getStaNo(), null, locTypeDto, 0);
			// // 工作号
			// int workNo = startupDto.getWorkNo();
			//
			// try {
			// // 插入工作主档
			// WrkMast wrkMast = new WrkMast();
			// wrkMast.setWrkNo(workNo);
			// wrkMast.setIoTime(new Date());
			// wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
			// wrkMast.setIoType(10); // 入出库状态：10.空板入库
			// wrkMast.setIoPri(10D); // 优先级：10
			// wrkMast.setCrnNo(startupDto.getCrnNo());
			// wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
			// wrkMast.setStaNo(startupDto.getStaNo());
			// wrkMast.setLocNo(startupDto.getLocNo());
			// wrkMast.setFullPlt("N"); // 满板
			// wrkMast.setPicking("N"); // 拣料
			// wrkMast.setExitMk("N"); // 退出
			// wrkMast.setEmptyMk("Y"); // 空板
			// wrkMast.setLinkMis("N");
			//// wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
			// // 操作人员数据
			// wrkMast.setAppeTime(new Date());
			// wrkMast.setModiTime(new Date());
			// Integer insert = wrkMastMapper.insert(wrkMast);
			// if (insert == 0) {
			// throw new CoolException("保存工作档失败");
			// }
			// // 更新目标库位状态
			// LocMast locMast = locMastService.selectById(startupDto.getLocNo());
			// locMast.setLocSts("S"); // S.入库预约
			// locMast.setModiTime(new Date());
			// if (!locMastService.updateById(locMast)){
			// throw new CoolException("改变库位状态失败");
			// }
			// // 命令下发区 --------------------------------------------------------------------------
			//
			// // 更新站点信息且下发plc命令
			// staProtocol.setWorkNo((short) workNo);
			// staProtocol.setStaNo(startupDto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败");
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }

			}

			@@ -1553,7 +1747,7 @@
			// 获取叉车站点
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			if (staProtocol == null) { continue; }
			if (staProtocol.getWorkNo() != 0) {
			if (staProtocol.getWorkNo() != 0 \|\| staProtocol.isErr()) {
			reset = false;
			break;
			}
			@@ -2094,55 +2288,1464 @@

			}

			public synchronized void outOfDevp() {
			List<WrkMast> wrkMasts = wrkMastMapper.selectPick();
			for (WrkMast wrkMast : wrkMasts) {
			if (basDevpService.selectCount(new EntityWrapper<BasDevp>().eq("wrk_no", wrkMast.getWrkNo())) == 0) {
			wrkMast.setCtnNo("Y");






			/**
			* 扫描碟盘机自动入库空托盘
			*/
			public synchronized void autoEmptyIn() {
			for (DevpSlave slave : slaveProperties.getDevp()) {
			for (DevpSlave.Sta sta : slave.getAutoEmptyIn()) {
			// 获取空板入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, slave.getId());
			StaProtocol staProtocol = devpThread.getStation().get(sta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// 站点条件判断
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
			&& staProtocol.isEmptyInPalletRequire() && staProtocol.getWorkNo() == 0) {
			List<StaDesc> staDescs = staDescService.selectList(new EntityWrapper<StaDesc>().eq("type_no", 10).eq("stn_no", sta.getStaNo()));
			for (StaDesc staDesc:staDescs){

			BasDevp basDevp = new BasDevp();

			if (staDesc.getCrnNo() == 1){
			basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", 1004));
			} else if (staDesc.getCrnNo() == 2) {
			basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", 1008));
			}
			if (Cools.isEmpty(basDevp)){
			continue;
			}

			if (basDevp.getAutoing().equals("Y") && basDevp.getLoading().equals("N")
			&& basDevp.getWrkNo() == 0 && basDevp.getCanining().equals("Y")){
			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo((short) 9997);
			staProtocol.setStaNo((short) (basDevp.getDevNo()==1004?1003:1013));
			// staProtocol.setStaNo((short) 1013);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败");
			}
			return;
			}

			}


			// try {
			// LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			//
			// SearchLocParam param = new SearchLocParam();
			// param.setIoType(10);
			// param.setSourceStaNo(sta.getStaNo());
			// param.setLocType1(locTypeDto.getLocType1());
			// String response = new HttpHandler.Builder()
			// .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);
			//
			// // 更新站点信息且下发plc命令
			// staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			// staProtocol.setStaNo(dto.getStaNo().shortValue());
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败");
			// }
			// } else {
			// log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			}
			}
			}
			}

			/**
			* 扫描拆盘机自动出库空托盘
			*/
			public synchronized void autoEmptyOut() {
			for (DevpSlave slave : slaveProperties.getDevp()) {
			for (DevpSlave.Sta sta : slave.getAutoEmptyOut()) {
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, slave.getId());
			StaProtocol staProtocol = devpThread.getStation().get(sta.getStaNo());
			if (staProtocol == null) {
			return;
			} else {
			staProtocol = staProtocol.clone();
			}

			if (staProtocol.isAutoing() //自动
			&& !staProtocol.isLoading() //无物
			&& staProtocol.isEmptyOutPalletRequire() //空托盘需求信号
			// && staProtocol.isEmptyMk()
			&& staProtocol.getWorkNo() == 0
			) {
			Integer staNo = sta.getStaNo();
			switch (staProtocol.getSiteId()){
			case 4007:
			staNo = 4002;break;
			case 4016:
			staNo = 4011;break;
			}
			WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(staNo);
			if (null != pakoutEmpty) {
			return;
			}

			List<StaDesc> staDescs = staDescService.selectList(new EntityWrapper<StaDesc>().eq("stn_no", staNo));
			for (StaDesc staDesc: staDescs){
			BasCrnp basCrnp = basCrnpService.selectOne(new EntityWrapper<BasCrnp>().eq("crn_no", staDesc.getCrnNo()));
			if (!basCrnp.getCrnSts().equals(3) \|\| basCrnp.getCrnErr() != 0){
			continue;
			}
			try {
			HashMap<String, Object> map = new HashMap<>();
			map.put("crnNo", staDesc.getCrnNo());//目标站
			map.put("staNo",staDesc.getStnNo());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setParams(map)
			.setPath("/rpc/auto/emptyOut/v1")
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			JSONObject data = (JSONObject) jsonObject.get("data");
			log.info((String) data.get("msg"));
			return;
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1","", response);
			}
			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}

			}
			}

			}

			}

			public synchronized void crn5InTask(){
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			if (crnSlave.getId() != 5){
			continue;
			}
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnSlave.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) {
			continue;
			}
			BasCrnp basCrnp = basCrnpService.selectById(crnSlave.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crnSlave.getId());
			continue;
			}
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
			&& crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {

			// Crn5InTaskSta(crnSlave,crnProtocol);

			// 如果最近一次是入库模式
			if (crnProtocol.getLastIo().equals("I")) {
			if (basCrnp.getInEnable().equals("Y")) {
			this.Crn5InTaskSta(crnSlave,crnProtocol);
			crnProtocol.setLastIo("O");
			} else if (basCrnp.getOutEnable().equals("Y")) {
			this.locToCrn5Stn(crnSlave, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			}
			}
			// 如果最近一次是出库模式
			else if (crnProtocol.getLastIo().equals("O")) {
			if (basCrnp.getOutEnable().equals("Y")) {
			this.locToCrn5Stn(crnSlave, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			} else if (basCrnp.getInEnable().equals("Y")) {

			this.Crn5InTaskSta(crnSlave,crnProtocol);
			crnProtocol.setLastIo("O");
			}
			}

			}

			}
			}
			public void Crn5InTaskSta(CrnSlave slave, CrnProtocol crnProtocol){
			for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
			// 查询工作档
			WrkMast wrkMast = wrkMastMapper.selectCrn5Task2();
			if (wrkMast == null) {
			return;
			}
			// 获取库位信息
			LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
			if (locMast == null) {
			log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			return;
			}
			if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
			log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			return;
			}
			// 堆垛机控制过滤
			if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			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(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()); // 目标库位层
			crnCommand.setLocType1(locMast.getLocType1().shortValue()); // 货物类型
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 2.设备上走 => 3.吊车入库中
			Date now = new Date();
			wrkMast.setWrkSts(3L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改{}工作档失败，ctn_no", wrkMast.getWrkNo());
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}




			}


			public synchronized void crn5StnToOutStn() {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			if (crnSlave.getId() != 5){
			continue;
			}
			// 遍历堆垛机出库站
			for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			// if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()) {
			// 查询工作档
			WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(crnStn.getStaNo());
			if (wrkMast == null) {
			continue;
			}
			// 判断工作档条件
			if (wrkMast.getIoType() < 100 \|\| wrkMast.getStaNo() == null \|\| wrkMast.getSourceStaNo() == null) {
			continue;
			}
			// 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol.statusType == CrnStatusType.FETCHING \|\| crnProtocol.statusType == CrnStatusType.PUTTING) {
			// 移动中
			continue;
			}
			// 判断堆垛机状态等待确认
			if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
			&& crnProtocol.statusType == CrnStatusType.WAITING
			&& crnProtocol.forkPosType == CrnForkPosType.HOME) {

			// 更新工作档状态为14
			wrkMast.setWrkSts(14L);

			wrkMast.setCrnEndTime(new Date());
			if (wrkMastMapper.updateById(wrkMast) != 0) {
			// 复位堆垛机
			crnThread.setResetFlag(true);
			} else {
			log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}

			}

			// }
			}
			}
			}


			public synchronized void locToCrn5Stn(CrnSlave slave, CrnProtocol crnProtocol) {
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			// 获取工作状态为11（生成出库ID）的出库工作档
			// WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
			List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo());
			// 获取工作状态为14的工作档
			WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep14(slave.getId(), crnStn.getStaNo());
			if ( wrkMast1 !=null) {
			continue;
			}
			for (WrkMast wrkMast : wrkMasts) {
			if (wrkMast == null) {
			continue;
			}
			// 工作档状态判断
			if (wrkMast.getIoType() < 100 \|\| wrkMast.getSourceStaNo() == null) {
			log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			continue;
			}
			// 获取源库位信息
			LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
			if (!locMast.getLocSts().equals("R") && !locMast.getLocSts().equals("P")) {
			log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			continue;
			}
			// 获取堆垛机出库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			break;
			// continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			break;
			// continue;
			}
			// 判断堆垛机出库站状态
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.isOutEnable()) {
			// 命令下发区 --------------------------------------------------------------------------

			// 堆垛机控制过滤
			if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			// continue;
			break;
			}


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

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

			public synchronized void crn5TaskCreate() throws IOException {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			if (crnSlave.getId() != 5){
			continue;
			}
			for (CrnSlave.CrnStn crnStn : crnSlave.getCrnInStn()) {
			// 获取堆垛机出库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			break;
			// continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()){

			EmptyBarrelIn emptyBarrelIn = emptyBarrelInService.selectOne(new EntityWrapper<>());
			if (Cools.isEmpty(emptyBarrelIn)){
			continue;
			}

			FullStoreParam fullStoreParam = new FullStoreParam();
			fullStoreParam.setDevpNo(crnStn.getStaNo());
			FullStoreParam.MatCodeStore matCodeStore = new FullStoreParam.MatCodeStore();
			matCodeStore.setMatnr(emptyBarrelIn.getMatnr());
			matCodeStore.setBatch(emptyBarrelIn.getBatch());
			if (staProtocol.isForce()){
			log.info("空桶强制入库："+staProtocol.getAmount());
			matCodeStore.setAnfme(Double.valueOf(staProtocol.getAmount()));
			}else {
			matCodeStore.setAnfme(8d) ;
			}
			ArrayList<FullStoreParam.MatCodeStore> matCodeStores = new ArrayList<>();
			matCodeStores.add(matCodeStore);
			fullStoreParam.setList(matCodeStores);
			try {
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/full/store/put/start")
			.setJson(JSON.toJSONString(fullStoreParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			devpThread.setPakMk(crnStn.getStaNo(),false);
			}
			}catch (CoolException e){

			}

			}

			}
			}
			}

			public synchronized void RGVTaskCreate(){
			for (RgvSlave rgvSlave:slaveProperties.getRgv()){
			ZyRgvThread rgvThread = (ZyRgvThread)SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (Cools.isEmpty(rgvProtocol)){
			continue;
			}else {
			rgvProtocol = rgvProtocol.clone();
			}
			List<WrkMastSta> wrkMastStas = wrkMastStaService.selectRGVTask1(rgvSlave.getId());
			if (!Cools.isEmpty(wrkMastStas)){
			continue;
			}
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.IDLE && rgvProtocol.getLoaded1() == 0){
			boolean work1 = false;
			boolean work2 = false;
			int workNo1 = 0;
			int workNo2 = 0;
			short souSta1 = 0;
			short sta1 = 0;
			short souSta2 = 0;
			short sta2 = 0;
			String matnr = "0";
			String matnr2 = "0";
			String batch = "";
			String batch2 = "";
			short type = 0;
			short type2 = 0;
			short anfme = 4;
			short anfme2 = 4;
			Double weight = 0d;
			Double weight2 = 0d;
			Double weight11 = 0d;
			String memo = "";
			String memo2 = "";

			List<RgvSlave.Sta> inStn1 = rgvSlave.getInStn();
			if (rgvProtocol.getColumnNumber()>4){
			short rgvStaNo = Utils.getRgvStaNo(rgvSlave.getId(), inStn1.get(0).getSourceStaNo());
			if (rgvStaNo<5){
			Collections.reverse(inStn1);
			}
			}
			//工位一任务
			for (RgvSlave.Sta inStn : inStn1){
			work1 = false;
			workNo1 = 0;
			souSta1 = 0;
			sta1 = 0;
			type = 0;
			if (rgvSlave.getId() == 1 && inStn.getSourceStaNo() == 2114){
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, inStn.getSourcePlcId());
			StaProtocol staProtocol = devpThread.getStation().get(inStn.getSourceStaNo());
			if (staProtocol == null) {
			// break;
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk() && (staProtocol.getWorkNo()>0 && staProtocol.getWorkNo()<9900)){

			WrkMast wrkMast = wrkMastService.selectByworkNo(staProtocol.getWorkNo());
			if (Cools.isEmpty(wrkMast)){
			log.error("未找到工作档");
			continue;
			}
			workNo1 = wrkMast.getWrkNo();
			souSta1 = Utils.getRgvStaNo(rgvSlave.getId(),staProtocol.getSiteId());
			sta1 = Utils.getRgvEndStaNo(rgvSlave.getId(),wrkMast.getStaNo());
			Integer staNo = Utils.getStaNo(rgvSlave.getId(), (int) sta1);
			BasDevp devp = basDevpService.selectById(staNo);
			if (devp.getWrkNo()!=0 \|\| Cools.isEmpty(devp.getLoading()) \|\| devp.getLoading().equals("Y")){
			continue;
			}
			work1 = true;
			devpThread.setPakMk(inStn.getSourceStaNo(),false);
			break;


			} else if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk() && (staProtocol.getWorkNo()>=9900 \|\| staProtocol.getWorkNo()==0)) {
			if (rgvSlave.getId() != 2 ){
			continue;
			}
			workNo1 = workNo++;
			souSta1 = Utils.getRgvStaNo(rgvSlave.getId(),inStn.getSourceStaNo());
			if (inStn.getSourceStaNo() == 4007 && staProtocol.getTongType() == 1){
			sta1 = Utils.getRgvStaNo(rgvSlave.getId(),2103);
			} else if (inStn.getSourceStaNo() == 4007 && staProtocol.getTongType() == 2) {
			sta1 = Utils.getRgvStaNo(rgvSlave.getId(),2002);
			} else if (inStn.getSourceStaNo() == 4007 && staProtocol.getTongType() == 4) {
			if (staProtocol.getStaNoEnd() == 3007 \|\| staProtocol.getStaNoEnd() == 3012){
			sta1 = Utils.getRgvStaNo(rgvSlave.getId(),2103);
			} else if (staProtocol.getStaNoEnd() == 2001 ){
			sta1 = Utils.getRgvStaNo(rgvSlave.getId(),2002);
			} else {
			log.error("4007站点，桶型4，非法目标站！！！！！！"+staProtocol.getStaNoEnd().toString());
			continue;
			}
			Integer staNo = Utils.getStaNo(rgvSlave.getId(), (int) sta1);
			BasDevp devp = basDevpService.selectById(staNo);
			if (devp.getWrkNo()!=0 \|\| Cools.isEmpty(devp.getLoading()) \|\| devp.getLoading().equals("Y")){
			continue;
			}
			workNo1 = commonService.getWorkNo(3);
			Date now = new Date();
			// 保存工作档
			WrkMast wrkMast = new WrkMast();
			wrkMast.setWrkNo(workNo1);
			wrkMast.setIoTime(now);
			wrkMast.setWrkSts(101L); // 工作状态：101.初始
			wrkMast.setIoType(199); // 入出库状态： 199.转移
			wrkMast.setIoPri(15D);
			wrkMast.setCrnNo(0);
			wrkMast.setSourceStaNo(4007); // 源站
			wrkMast.setStaNo(staProtocol.getStaNoEnd().intValue()); // 目标站
			wrkMast.setFullPlt("N"); // 满板
			wrkMast.setPicking("N"); // 拣料
			wrkMast.setExitMk("N"); // 退出
			wrkMast.setEmptyMk("Y"); // 空板
			wrkMast.setBarcode("KB888888"); // 托盘码
			wrkMast.setLinkMis("N");
			wrkMast.setCtnNo("Y"); // 入库阻塞库位移转标记
			wrkMast.setAppeTime(now);
			wrkMast.setModiTime(now);
			int res = wrkMastMapper.insert(wrkMast);
			if (res == 0) {
			// throw new CoolException("");
			log.error("4007站点，桶型4，保存工作档主档失败！！！！！！"+now.toString());
			continue;
			}
			type = 2;
			} else if (inStn.getSourceStaNo() == 2102 && staProtocol.isFullPlt()) {
			sta1 = Utils.getRgvStaNo(rgvSlave.getId(),2301);
			} else {
			sta1 = Utils.getRgvStaNo(rgvSlave.getId(),inStn.getStaNo());
			}

			if (inStn.getSourceStaNo() == 2102 && staProtocol.isEmptyMk()){ //区分空板
			type = 1;
			}
			if(inStn.getSourceStaNo() == 2102){
			weight = staProtocol.getWeight().doubleValue()/10;
			}
			Integer staNo = Utils.getStaNo(rgvSlave.getId(), (int) sta1);
			BasDevp devp = basDevpService.selectById(staNo);
			if (devp.getWrkNo()!=0 \|\| Cools.isEmpty(devp.getLoading()) \|\| devp.getLoading().equals("Y")){
			continue;
			}
			work1 = true;
			if (inStn.getSourcePlcId() == 4 \|\| inStn.getSourcePlcId() ==5){ //灌装站需要获取输送线物料代码
			matnr = staProtocol.getMatnr();
			batch = staProtocol.getBatch();
			anfme = (Cools.isEmpty(staProtocol.getAnfme()) \|\| staProtocol.getAnfme()==0) ? anfme:staProtocol.getAnfme().shortValue();
			weight11 = staProtocol.getWeight1();
			weight = weight11;
			String memoBool = staProtocol.isBan()? "存在":"不存在";
			memo = memoBool+"半桶";
			}
			devpThread.setPakMk(inStn.getSourceStaNo(),false);
			break;

			}
			}

			if (rgvSlave.getId() != 3){
			//工位二任务
			for (RgvSlave.Sta inStn : rgvSlave.getInStn()){
			work2 = false;
			workNo2 = 0;
			souSta2 = 0;
			sta2 = 0;
			type2 = 0;
			if (souSta1 == inStn.getSourceStaNo()){
			continue;
			}
			if (rgvSlave.getId() == 1 && inStn.getSourceStaNo() == 1014){
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, inStn.getSourcePlcId());
			StaProtocol staProtocol = devpThread.getStation().get(inStn.getSourceStaNo());
			if (staProtocol == null) {
			// break;
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()&& staProtocol.isPakMk() && (staProtocol.getWorkNo()>0 && staProtocol.getWorkNo()<9900)){

			WrkMast wrkMast = wrkMastService.selectByworkNo(staProtocol.getWorkNo());
			if (Cools.isEmpty(wrkMast)){
			log.error("未找到工作档");
			continue;
			}
			workNo2 = wrkMast.getWrkNo();
			souSta2 = Utils.getRgvStaNo(rgvSlave.getId(),staProtocol.getSiteId());
			sta2 = Utils.getRgvEndStaNo(rgvSlave.getId(),wrkMast.getStaNo());
			Integer staNo = Utils.getStaNo(rgvSlave.getId(), (int) sta2);
			BasDevp devp2 = basDevpService.selectById(staNo);
			if (devp2.getWrkNo()!=0 \|\| Cools.isEmpty(devp2.getLoading()) \|\| devp2.getLoading().equals("Y")){
			continue;
			}

			work2 = true;
			devpThread.setPakMk(inStn.getSourceStaNo(),false);
			break;
			} else if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk() && (staProtocol.getWorkNo()>=9900 \|\| staProtocol.getWorkNo()==0)) {
			if (rgvSlave.getId() != 2 ){
			continue;
			}
			workNo2 = workNo++;
			souSta2 = Utils.getRgvStaNo(rgvSlave.getId(),inStn.getSourceStaNo());
			if (inStn.getSourceStaNo() == 4007 && staProtocol.getTongType() == 1){
			sta2 = Utils.getRgvStaNo(rgvSlave.getId(),2103);
			} else if (inStn.getSourceStaNo() == 4007 && staProtocol.getTongType() == 2) {
			sta2 = Utils.getRgvStaNo(rgvSlave.getId(),2002);
			} else if (inStn.getSourceStaNo() == 4007 && staProtocol.getTongType() == 4) {
			if (staProtocol.getStaNoEnd() == 3007 \|\| staProtocol.getStaNoEnd() == 3012){
			sta2 = Utils.getRgvStaNo(rgvSlave.getId(),2103);
			} else if (staProtocol.getStaNoEnd() == 2001 ){
			sta2 = Utils.getRgvStaNo(rgvSlave.getId(),2002);
			} else {
			log.error("4007站点，桶型4，非法目标站！！！！！！"+staProtocol.getStaNoEnd().toString());
			continue;
			}
			Integer staNo = Utils.getStaNo(rgvSlave.getId(), (int) sta2);
			BasDevp devp2 = basDevpService.selectById(staNo);
			if (devp2.getWrkNo()!=0 \|\| Cools.isEmpty(devp2.getLoading()) \|\| devp2.getLoading().equals("Y")){
			continue;
			}
			workNo2 = commonService.getWorkNo(3);
			Date now = new Date();
			// 保存工作档
			WrkMast wrkMast = new WrkMast();
			wrkMast.setWrkNo(workNo2);
			wrkMast.setIoTime(now);
			wrkMast.setWrkSts(101L); // 工作状态：101.初始
			wrkMast.setIoType(199); // 入出库状态： 199.转移
			wrkMast.setIoPri(15D);
			wrkMast.setCrnNo(0);
			wrkMast.setSourceStaNo(4007); // 源站
			wrkMast.setStaNo(staProtocol.getStaNoEnd().intValue()); // 目标站
			wrkMast.setFullPlt("N"); // 满板
			wrkMast.setPicking("N"); // 拣料
			wrkMast.setExitMk("N"); // 退出
			wrkMast.setEmptyMk("Y"); // 空板
			wrkMast.setBarcode("KB888888"); // 托盘码
			wrkMast.setLinkMis("N");
			wrkMast.setCtnNo("Y"); // 入库阻塞库位移转标记
			wrkMast.setAppeTime(now);
			wrkMast.setModiTime(now);
			int res = wrkMastMapper.insert(wrkMast);
			if (res == 0) {
			// throw new CoolException("");
			log.error("4007站点，桶型4，保存工作档主档失败！！！！！！"+now.toString());
			continue;
			}
			type2 = 2;
			} else if (inStn.getSourceStaNo() == 2102 && staProtocol.isFullPlt()) {
			sta2 = Utils.getRgvStaNo(rgvSlave.getId(),2301);
			} else {
			sta2 = Utils.getRgvStaNo(rgvSlave.getId(),inStn.getStaNo());
			}

			if (inStn.getSourceStaNo() == 2102 && staProtocol.isEmptyMk()){ //区分空板
			type2 = 1;
			}

			if(inStn.getSourceStaNo() == 2102){
			weight2 = staProtocol.getWeight().doubleValue()/10;
			}
			Integer staNo = Utils.getStaNo(rgvSlave.getId(), (int) sta2);
			BasDevp devp2 = basDevpService.selectById(staNo);
			if (devp2.getWrkNo()!=0 \|\| Cools.isEmpty(devp2.getLoading()) \|\| devp2.getLoading().equals("Y")){
			continue;
			}

			work2 = true;
			if (inStn.getSourcePlcId() == 4){
			matnr2 = staProtocol.getMatnr();
			batch2 = staProtocol.getBatch();
			anfme2 = (Cools.isEmpty(staProtocol.getAnfme2()) \|\| staProtocol.getAnfme2()==0) ? anfme2:staProtocol.getAnfme2().shortValue();

			weight11 = staProtocol.getWeight1();
			weight2 = weight11;
			String memoBool = staProtocol.isBan()? "存在":"不存在";
			memo2 = memoBool+"半桶";
			}
			devpThread.setPakMk(inStn.getSourceStaNo(),false);
			break;
			}


			}
			}


			if (work1 \|\| work2){
			//rgv任务下发--------------------------------------------------------------
			RgvCommand command = new RgvCommand();
			command.setRgvNo(rgvSlave.getId()); // RGV编号
			//工位1
			command.setTaskNo1(workNo1); // 工作号
			command.setSourceStaNo1(souSta1); // 源站
			command.setDestinationStaNo1(sta1); // 目标站
			command.setAckFinish1(false); // 任务完成确认位

			//工位2
			command.setTaskNo2(workNo2); // 工作号
			command.setSourceStaNo2(souSta2); // 源站
			command.setDestinationStaNo2(sta2); // 目标站
			command.setAckFinish2(false); // 任务完成确认位

			command.setMatnr(matnr);
			command.setMatnr2(matnr2);
			command.setBatch(batch);
			command.setBatch2(batch2);
			command.setAnfme(anfme);
			command.setAnfme2(anfme2);

			command.setType(type);
			command.setType2(type2);

			command.setWeight(weight);
			command.setWeight2(weight2);

			if (workNo1 == 0 && workNo2 !=0){
			command.setTaskMode(RgvTaskModeType.FETCH_PUT2); // 任务模式: 2取放货
			} else if (workNo1 != 0 && workNo2 ==0) {
			command.setTaskMode(RgvTaskModeType.FETCH_PUT1); // 任务模式: 1取放货
			}else {
			command.setTaskMode(RgvTaskModeType.FETCH_PUT_ALL); // 任务模式: all取放货
			}
			command.setCommand(false);
			rgvTaskSave(command,memo,memo2);
			MessageQueue.offer(SlaveType.Rgv, rgvSlave.getId(), new Task(2, command));
			log.info("rgv任务下发："+JSON.toJSONString(command));
			}
			}

			}
			}

			public synchronized void autoEmptyOut() {
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			Integer autoOutSite = 12;
			//如果站点可出禁用，则不生成空盘出库任务
			StaProtocol staProtocol = devpThread.getStation().get(autoOutSite);
			if (staProtocol == null) {
			return;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() //自动
			&& !staProtocol.isLoading() //无物
			&& staProtocol.isOutEnable() //可出信号
			&& staProtocol.getWorkNo() == 0
			) {
			WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(autoOutSite);
			if (null != pakoutEmpty) {
			return;

			public synchronized void RGVTaskOver() {
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			if (rgvSlave.getId() ==2){
			continue;
			}
			try {
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/auto/emptyOut/v1")
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			JSONObject data = (JSONObject) jsonObject.get("data");
			log.info((String) data.get("msg"));
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1","", response);
			ZyRgvThread rgvThread = (ZyRgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (Cools.isEmpty(rgvProtocol)){
			continue;
			}else {
			rgvProtocol = rgvProtocol.clone();
			}

			//工位一任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.WAITING && rgvProtocol.getLoaded1() == 0) {

			try {
			boolean offer = MessageQueue.offer(SlaveType.Rgv, rgvSlave.getId(), new Task(3, new RgvCommand()));
			log.info("{}号rgv工位一工作完成复位,工作号:{}",rgvSlave.getId(),rgvProtocol.getTaskNo1());
			if (offer){
			//完成rgv任务
			Wrapper<WrkMastSta> wrkMastStaWrapper = new EntityWrapper<WrkMastSta>().eq("wrk_crn", rgvSlave.getId()).eq("wrk_no", rgvProtocol.getTaskNo1());
			WrkMastSta wrkMastSta1 = wrkMastStaService.selectOne(wrkMastStaWrapper);
			if (Cools.isEmpty(wrkMastSta1)){
			log.error("完成{}号车工位一任务未找到对应rgv任务,{}",rgvSlave.getId(),rgvProtocol.getTaskNo1());
			}else {
			if (wrkMastSta1.getWrkType() == 8 ){
			wrkMastSta1.setWrkSts(3);
			wrkMastStaService.update(wrkMastSta1,wrkMastStaWrapper);
			}
			}

			//完成工作档任务
			if (rgvSlave.getId() != 1){
			WrkMast wrkMast = wrkMastService.selectByworkNo(rgvProtocol.getTaskNo1());
			if (Cools.isEmpty(wrkMast)){
			log.error("完成{}号车工位一任务未找到对应rgv任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			} else {
			if (wrkMast.getIoType() == 110 \|\| wrkMast.getIoType() == 101){
			Date date = new Date();
			wrkMast.setWrkSts(14L);
			wrkMast.setModiTime(date);
			wrkMastService.updateById(wrkMast);
			} else if (wrkMast.getIoType()==199 && rgvSlave.getId()==3 && (wrkMast.getStaNo()==3007 \|\| wrkMast.getStaNo()==3012)){
			Date date = new Date();
			wrkMast.setWrkSts(105L);
			wrkMast.setModiTime(date);
			wrkMastService.updateById(wrkMast);
			}
			}
			}
			}


			}catch (Exception e){
			log.error("完成{}号车工位一任务出错!!!!!!!!!!!!!!!!,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			continue;
			}
			} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();



			}

			//工位二任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.WAITING2 && rgvProtocol.getLoaded2() == 0) {
			try {
			boolean offer = MessageQueue.offer(SlaveType.Rgv, rgvSlave.getId(), new Task(4, new RgvCommand()));
			log.info("{}号rgv工位二工作完成复位,工作号:{}",rgvSlave.getId(),rgvProtocol.getTaskNo2());
			if (offer){
			//完成rgv任务
			Wrapper<WrkMastSta> wrkMastStaWrapper = new EntityWrapper<WrkMastSta>().eq("wrk_crn", rgvProtocol.getRgvNo()).eq("wrk_no2", rgvProtocol.getTaskNo2());
			WrkMastSta wrkMastSta1 = wrkMastStaService.selectOne(wrkMastStaWrapper);
			if (Cools.isEmpty(wrkMastSta1)){
			log.error("完成{}号车工位二任务未找到对应工作任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo2());
			}else {
			if (wrkMastSta1.getWrkType() == 9 ){
			wrkMastSta1.setWrkSts(3);
			wrkMastStaService.update(wrkMastSta1,wrkMastStaWrapper);
			}else if (wrkMastSta1.getWrkType() == 1){
			wrkMastSta1.setWrkSts(3);
			wrkMastStaService.update(wrkMastSta1,wrkMastStaWrapper);
			}
			}

			//完成工作档任务
			if (rgvSlave.getId() != 1){
			WrkMast wrkMast = wrkMastService.selectByworkNo(rgvProtocol.getTaskNo2());
			if (Cools.isEmpty(wrkMast)){
			log.error("完成{}号车工位一任务未找到对应rgv任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo2());
			}else {
			if (wrkMast.getIoType() == 110 \|\| wrkMast.getIoType() == 101){
			Date date = new Date();
			wrkMast.setWrkSts(14L);
			wrkMast.setModiTime(date);
			wrkMastService.updateById(wrkMast);
			}
			}
			}

			}

			}catch (Exception e){
			log.error("完成{}号车工位一任务出错!!!!!!!!!!!!!!!!,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			continue;
			}




			}
			}
			}

			//二号rgv输送线命令下发
			public synchronized void RGVTaskput() {
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			if (rgvSlave.getId() ==2){
			continue;
			}
			ZyRgvThread rgvThread = (ZyRgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (Cools.isEmpty(rgvProtocol)){
			continue;
			}else {
			rgvProtocol = rgvProtocol.clone();
			}

			//工位一任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.OUTSTN1 && rgvProtocol.getLoaded1() == 1) {
			WrkMastSta wrkMastSta = wrkMastStaService.selectByRgvNoandWrkNo(rgvSlave.getId(), rgvProtocol.getTaskNo1());
			WrkMast wrkMast = wrkMastService.selectByworkNo(rgvProtocol.getTaskNo1());
			if (Cools.isEmpty(wrkMastSta)){
			log.error("未查询到rgv工作任务，rgv编号{},工作号{}",rgvSlave.getId(),rgvProtocol.getTaskNo1());
			continue;
			}
			for (RgvSlave.Sta outStn :rgvSlave.getOutStn()){
			if (!Objects.equals(Utils.getStaNo(rgvSlave.getId(), wrkMastSta.getWrkEnd()), outStn.getStaNo())){
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, outStn.getStaPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(outStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.isPakMk()){
			staProtocol.setWorkNo(wrkMastSta.getWrkNo().shortValue());
			if (rgvSlave.getId() == 3 && outStn.getStaPlcId() == 6){
			staProtocol.setStaNo((short)2401);
			}else {
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			}

			MessageQueue.offer(SlaveType.Devp, outStn.getStaPlcId(), new Task(2, staProtocol));
			}
			}
			}

			//工位二任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.OUTSTN8 && rgvProtocol.getLoaded2() == 1) {
			WrkMastSta wrkMastSta = wrkMastStaService.selectByRgvNoandWrkNo2(rgvProtocol.getRgvNo(), rgvProtocol.getTaskNo2());
			WrkMast wrkMast = wrkMastService.selectByworkNo(rgvProtocol.getTaskNo2());
			if (Cools.isEmpty(wrkMastSta)){
			log.error("未查询到rgv工作任务，rgv编号{},工作号{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo2());
			continue;
			}
			for (RgvSlave.Sta outStn :rgvSlave.getOutStn()){
			if (!Objects.equals(Utils.getStaNo(rgvSlave.getId(), wrkMastSta.getStaEnd()), outStn.getStaNo())){
			continue;
			}//判断是否为工作档站点
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, outStn.getStaPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(outStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.isPakMk()){
			staProtocol.setWorkNo(wrkMastSta.getWrkNo2().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, outStn.getStaPlcId(), new Task(2, staProtocol));
			}
			}
			}
			}
			}

			//二号rgv输送线命令下发
			public synchronized void RGV2Taskput() {
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			if (rgvSlave.getId() !=2){
			continue;
			}
			ZyRgvThread rgvThread = (ZyRgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (Cools.isEmpty(rgvProtocol)){
			continue;
			}else {
			rgvProtocol = rgvProtocol.clone();
			}

			//工位一任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.OUTSTN1 && rgvProtocol.getLoaded1() == 1) {
			WrkMastSta wrkMastSta = wrkMastStaService.selectByRgvNoandWrkNo(rgvProtocol.getRgvNo(), rgvProtocol.getTaskNo1());
			if (Cools.isEmpty(wrkMastSta)){
			log.error("未查询到rgv工作任务，rgv编号{},工作号{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			continue;
			}
			for (RgvSlave.Sta outStn :rgvSlave.getOutStn()){
			if (!Objects.equals(Utils.getStaNo(rgvSlave.getId(), wrkMastSta.getWrkEnd()), outStn.getStaNo())){
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, outStn.getStaPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(outStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			if (outStn.getStaPlcId() == 2){
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.isPakMk()){
			staProtocol.setWorkNo(wrkMastSta.getWrkNo().shortValue());
			if (wrkMastSta.getType() == 1){
			staProtocol.setStaNo((short) 9999);
			} else if (wrkMastSta.getType() == 2){//转运
			staProtocol.setStaNo((short) 2114);
			} else {
			staProtocol.setStaNo((short) 2106);
			}
			staProtocol.setMatnr(wrkMastSta.getMatnr1());

			if (!MessageQueue.offer(SlaveType.Devp, outStn.getStaPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			}
			}

			}
			}

			//工位二任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.OUTSTN8 && rgvProtocol.getLoaded2() == 1) {
			WrkMastSta wrkMastSta = wrkMastStaService.selectByRgvNoandWrkNo2(rgvProtocol.getRgvNo(), rgvProtocol.getTaskNo2());
			if (Cools.isEmpty(wrkMastSta)){
			log.error("未查询到rgv工作任务，rgv编号{},工作号{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo2());
			continue;
			}
			for (RgvSlave.Sta outStn :rgvSlave.getOutStn()){
			if (!Objects.equals(Utils.getStaNo(rgvSlave.getId(), wrkMastSta.getStaEnd()), outStn.getStaNo())){
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, outStn.getStaPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(outStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (outStn.getStaPlcId() == 2){
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.isPakMk()){
			staProtocol.setWorkNo(wrkMastSta.getWrkNo2().shortValue());
			if (wrkMastSta.getType2() == 1){
			staProtocol.setStaNo((short) 9999);
			} else if (wrkMastSta.getType() == 2){//转运
			staProtocol.setStaNo((short) 2114);
			} else {
			staProtocol.setStaNo((short) 2106);
			}

			staProtocol.setMatnr(wrkMastSta.getMatnr2());

			if (!MessageQueue.offer(SlaveType.Devp, outStn.getStaPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			}
			}
			}
			}
			}
			}

			public synchronized void RGV2TaskOver() {
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			if (rgvSlave.getId() !=2){
			continue;
			}
			ZyRgvThread rgvThread = (ZyRgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (Cools.isEmpty(rgvProtocol)){
			continue;
			}else {
			rgvProtocol = rgvProtocol.clone();
			}

			//工位一任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.WAITING && rgvProtocol.getLoaded1() == 0) {

			try {
			boolean offer = MessageQueue.offer(SlaveType.Rgv, rgvSlave.getId(), new Task(3, new RgvCommand()));
			log.info("{}号rgv工位一工作完成复位,工作号:{}",rgvSlave.getId(),rgvProtocol.getTaskNo1());
			if (offer){

			Wrapper<WrkMastSta> wrkMastStaWrapper = new EntityWrapper<WrkMastSta>().eq("wrk_crn", rgvProtocol.getRgvNo()).eq("wrk_no", rgvProtocol.getTaskNo1());
			WrkMastSta wrkMastSta1 = wrkMastStaService.selectOne(wrkMastStaWrapper);
			if (Cools.isEmpty(wrkMastSta1)){
			log.error("完成{}号车工位一任务未找到对应rgv任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			}else {
			if (wrkMastSta1.getWrkType() == 8 ){
			wrkMastSta1.setWrkSts(3);
			wrkMastStaService.update(wrkMastSta1,wrkMastStaWrapper);
			}
			}

			//完成工作档任务
			WrkMast wrkMast = wrkMastService.selectByworkNo(rgvProtocol.getTaskNo1());
			if (Cools.isEmpty(wrkMast)){
			log.error("完成{}号车工位一任务未找到对应rgv任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			}else {
			if (wrkMast.getIoType() == 110 \|\| wrkMast.getIoType() == 101){
			Date date = new Date();
			wrkMast.setWrkSts(14L);
			wrkMast.setModiTime(date);
			wrkMastService.updateById(wrkMast);
			} else if (wrkMast.getIoType()==199 && wrkMast.getStaNo()==2001){
			Date date = new Date();
			wrkMast.setWrkSts(105L);
			wrkMast.setModiTime(date);
			wrkMastService.updateById(wrkMast);
			}
			}


			}


			}catch (Exception e){
			log.error("完成{}号车工位一任务出错!!!!!!!!!!!!!!!!,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			continue;
			}



			}

			//工位二任务完成
			if (rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType() == RgvStatusType.WAITING2 && rgvProtocol.getLoaded2() == 0) {
			try {
			boolean offer = MessageQueue.offer(SlaveType.Rgv, rgvSlave.getId(), new Task(4, new RgvCommand()));
			log.info("{}号rgv工位二工作完成复位,工作号:{}",rgvSlave.getId(),rgvProtocol.getTaskNo2());
			if (offer){
			Wrapper<WrkMastSta> wrkMastStaWrapper = new EntityWrapper<WrkMastSta>().eq("wrk_crn", rgvProtocol.getRgvNo()).eq("wrk_no2", rgvProtocol.getTaskNo2());
			WrkMastSta wrkMastSta1 = wrkMastStaService.selectOne(wrkMastStaWrapper);
			if (Cools.isEmpty(wrkMastSta1)){
			log.error("完成{}号车工位二任务未找到对应工作任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo2());
			}else {
			if (wrkMastSta1.getWrkType() == 9 ){
			wrkMastSta1.setWrkSts(3);
			wrkMastStaService.update(wrkMastSta1,wrkMastStaWrapper);
			}else if (wrkMastSta1.getWrkType() == 1){
			wrkMastSta1.setWrkSts(3);
			wrkMastStaService.update(wrkMastSta1,wrkMastStaWrapper);
			}
			}

			//完成工作档任务
			WrkMast wrkMast = wrkMastService.selectByworkNo(rgvProtocol.getTaskNo2());
			if (Cools.isEmpty(wrkMast)){
			log.error("完成{}号车工位一任务未找到对应rgv任务,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo2());
			}else {
			if (wrkMast.getIoType() == 110 \|\| wrkMast.getIoType() == 101){
			Date date = new Date();
			wrkMast.setWrkSts(14L);
			wrkMast.setModiTime(date);
			wrkMastService.updateById(wrkMast);
			}
			}

			}


			}catch (Exception e){
			log.error("完成{}号车工位一任务出错!!!!!!!!!!!!!!!!,{}",rgvProtocol.getRgvNo(),rgvProtocol.getTaskNo1());
			continue;
			}




			}
			}
			}

			public boolean rgvTaskSave(RgvCommand command,String memo,String memo2){
			// Wrapper<WrkMastSta> wrkMastStaWrapper = new EntityWrapper<WrkMastSta>().eq("wrk_crn", command.getRgvNo()).eq("wrk_no", command.getTaskNo1());
			if (command.getTaskNo1() > 0){
			List<WrkMastSta> wrkMastSta1 = wrkMastStaService.selectBywrkNoHistoricalTasks(command.getRgvNo(),command.getTaskNo1());
			if (!Cools.isEmpty(wrkMastSta1)){
			for (WrkMastSta wrkMastSta :wrkMastSta1){
			wrkMastStaService.deleteById(wrkMastSta);
			}

			}
			}
			if (command.getTaskNo2() > 0){
			List<WrkMastSta> wrkMastSta1 = wrkMastStaService.selectBywrkNoHistoricalTasks2(command.getRgvNo(),command.getTaskNo2());
			if (!Cools.isEmpty(wrkMastSta1)){
			for (WrkMastSta wrkMastSta :wrkMastSta1){
			wrkMastStaService.deleteById(wrkMastSta);
			}

			}
			}


			WrkMastSta wrkMastSta = new WrkMastSta();
			wrkMastSta.setWrkNo(Long.valueOf(command.getTaskNo1()));
			wrkMastSta.setWrkNo2(Long.valueOf(command.getTaskNo2()));
			wrkMastSta.setWrkStart(command.getSourceStaNo1().intValue());
			wrkMastSta.setWrkEnd(command.getDestinationStaNo1().intValue());
			wrkMastSta.setStaStart(command.getSourceStaNo2().intValue());
			wrkMastSta.setStaEnd(command.getDestinationStaNo2().intValue());
			wrkMastSta.setWrkSts(1);
			Date now = new Date();
			wrkMastSta.setCreateTime(now);
			wrkMastSta.setUpdateTime(now);
			wrkMastSta.setWrkCrn(command.getRgvNo());
			wrkMastSta.setWrkType(command.getTaskMode().intValue());
			wrkMastSta.setMatnr1(command.getMatnr());
			wrkMastSta.setMatnr2(command.getMatnr2());
			wrkMastSta.setType(command.getType().intValue());
			wrkMastSta.setType2(command.getType2().intValue());
			wrkMastSta.setBatch(command.getBatch());
			wrkMastSta.setBatch2(command.getBatch2());
			wrkMastSta.setAnfme(command.getAnfme().intValue());
			wrkMastSta.setAnfme2(command.getAnfme2().intValue());
			wrkMastSta.setWeight(command.getWeight());
			wrkMastSta.setWeight2(command.getWeight2());
			wrkMastSta.setMemo(memo);
			wrkMastSta.setMemo2(memo2);

			return wrkMastStaService.insert(wrkMastSta);
			}

			//二期组托
			public synchronized void generateStoreWrkFile2() {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			if (devp.getId() != 2){
			continue;
			}
			// 遍历入库口
			for (DevpSlave.Sta inSta : devp.getInSta()) {
			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			if (barcodeThread == null) {
			continue;
			}
			String barcode = barcodeThread.getBarcode();
			// 获取入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if ("NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			continue;
			}
			} else {
			// led 异常显示
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			// if (ledThread != null) {
			// String errorMsg = "扫码失败，请重试";
			// MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			// }
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk()
			&& staProtocol.getStaNo() != 9999
			&& staProtocol.isPakMk()) {

			if(Cools.isEmpty(barcode) \|\| "NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			//条码为空或者不符合，退库到
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			String errorMsg = "扫码失败，请重试";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			continue;
			}

			// 判断重复工作档
			WrkMast wrkMast = new WrkMast();
			if (barcode.length() == 8) {
			wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			if (wrkMast != null) {
			log.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			continue;
			}
			}
			// 获取入库通知档
			WaitPakin waitPakin = waitPakinService.selectOne(new EntityWrapper<WaitPakin>().eq("zpallet", barcode).eq("io_status", "N"));
			if (Cools.isEmpty(waitPakin)) {
			try {
			CreateComb(barcode, staProtocol.getMatnr().toString(),staProtocol.getWorkNo().intValue(),staProtocol.getBatch(),inSta);
			}catch (IOException e) {
			throw new CoolException(e);
			}
			} else if (waitPakin.getWeight() == null) {
			WrkMastSta wrkMastSta = wrkMastStaService.selectOne(new EntityWrapper<WrkMastSta>().eq("wrk_no", staProtocol.getWorkNo().intValue()));
			if (Cools.isEmpty(wrkMastSta)){
			wrkMastSta = wrkMastStaService.selectOne(new EntityWrapper<WrkMastSta>().eq("wrk_no2", staProtocol.getWorkNo().intValue()));
			if (Cools.isEmpty(wrkMastSta)){
			throw new CoolException("未找到对应的任务信息");
			}
			waitPakin.setWeight(wrkMastSta.getWeight2());
			}else {
			waitPakin.setWeight(wrkMastSta.getWeight());
			}
			waitPakinService.update(waitPakin,new EntityWrapper<WaitPakin>().eq("zpallet", barcode).eq("io_status", "N"));
			} else {
			try {
			LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
			SearchLocParam param = new SearchLocParam();
			param.setBarcode(barcode);
			param.setIoType(1);
			param.setSourceStaNo(inSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			.setJson(JSON.toJSONString(param))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (jsonObject.getInteger("code").equals(200)) {
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			barcodeThread.setBarcode("");
			staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			staProtocol.setStaNo(dto.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			ledThread.errorReset();
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败");
			}
			} else if(jsonObject.getInteger("code").equals(700)) {
			log.error(barcode + "托盘识别异常，请先进行组托！");
			// led 异常显示
			ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			String errorMsg = barcode + "托盘识别异常，请先进行组托！";
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
			}
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}

			} catch (Exception e) {
			log.error(""+e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}


			}

			}
			}

			}

			public void CreateComb(String barcode,String code,Integer wrkNo,String batch,DevpSlave.Sta inSta) throws IOException {
			Double anfme = 0d;
			Double weight = 0d;
			String memo = "";

			WrkMastSta wrkMastSta = wrkMastStaService.selectOne(new EntityWrapper<WrkMastSta>().eq("wrk_no", wrkNo));
			if (Cools.isEmpty(wrkMastSta)){
			wrkMastSta = wrkMastStaService.selectOne(new EntityWrapper<WrkMastSta>().eq("wrk_no2", wrkNo));
			if (Cools.isEmpty(wrkMastSta)){
			if (!Cools.isEmpty(batch)){
			anfme = 1d;
			}else {
			throw new CoolException("未找到对应的任务信息");
			}
			}else {
			batch = wrkMastSta.getBatch2();
			anfme = wrkMastSta.getAnfme2().doubleValue();
			code = wrkMastSta.getMatnr2();
			weight = wrkMastSta.getWeight2();
			memo = wrkMastSta.getMemo2();
			}
			}else {
			batch = wrkMastSta.getBatch();
			anfme = wrkMastSta.getAnfme().doubleValue();
			code = wrkMastSta.getMatnr1();
			weight = wrkMastSta.getWeight();
			memo = wrkMastSta.getMemo();
			}
			////
			// MatnrCode matnrCode = matnrCodeService.selectByCode(code);
			Mat mat = matService.selectByCode(code);
			if (Cools.isEmpty(mat)){
			throw new CoolException("未找到对应的物料信息");
			}
			CombParam combParam = new CombParam();
			ArrayList<CombParam.CombMat> combMats = new ArrayList<>();
			CombParam.CombMat combMat = new CombParam.CombMat();
			combParam.setBarcode(barcode);
			combMat.setMatnr(mat.getMatnr());
			combMat.setBatch(batch);
			combMat.setAnfme(anfme);
			combMat.setWeight(weight);
			combMat.setMemo(memo);

			combMats.add(combMat);
			combParam.setCombMats(combMats);

			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/mobile/comb/auth")
			.setJson(JSON.toJSONString(combParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {

			}else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/mobile/comb/auth", JSON.toJSONString(combParam), response);
			// log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			//条码为空或者不符合，退库信号下发
			boolean result = MessageQueue.offer(SlaveType.Devp, 2, new Task(3, null));
			}
			}