zy-wcs.git - Gitblit

			@@ -24,6 +24,7 @@
			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.*;
			@@ -46,6 +47,7 @@
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;

			import java.io.IOException;
			import java.util.*;
			import java.util.stream.Collectors;

			@@ -86,9 +88,19 @@
			private BasErrLogService basErrLogService;
			@Autowired
			private BasCrnErrorMapper basCrnErrorMapper;
			@Autowired
			private EmptyBarrelInService emptyBarrelInService;
			@Autowired
			private WrkMastStaService wrkMastStaService;
			@Autowired
			private MatnrCodeService matnrCodeService;
			@Autowired
			private WaitPakinService waitPakinService;

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

			public int workNo = 9900;

			/**
			* 组托
			@@ -143,6 +155,250 @@
			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);
			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();
			}
			}

			}
			}

			}
			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;
			@@ -369,7 +625,7 @@
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& staProtocol.isPakMk()
			&& staProtocol.getWorkNo() == 9991) {
			&& staProtocol.getWorkNo() == 9999) {
			// WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
			if (barcode.equals("") \|\| barcode.equals("99999999")) {
			@@ -389,8 +645,9 @@
			continue;
			}

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

			if (wrkMast == null) {
			wrkMast = wrkMastMapper.selectPickStep(barcode);
			}
			@@ -474,6 +731,8 @@
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}else {
			ledThread.errorReset();
			}

			}
			@@ -488,6 +747,9 @@
			*/
			public synchronized void crnStnToOutStn() {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			if (crnSlave.getId() ==5){
			continue;
			}
			// 遍历堆垛机出库站
			for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
			// 获取堆垛机出库站信息
			@@ -519,17 +781,20 @@
			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;
			}
			}

			if (crnStn.getStaNo() == 1016 \|\| crnStn.getStaNo() == 1019) {

			if (crnStn.getStaNo() > 1013) {
			// 更新工作档状态为13.RGV搬运中
			wrkMast.setWrkSts(13L);
			}else {
			@@ -556,6 +821,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();
			@@ -579,6 +847,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")) {
			@@ -592,6 +863,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");
			}
			@@ -804,10 +1079,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;
			@@ -1132,6 +1407,7 @@
			}
			// 状态：等待确认并且任务完成位 = 1
			if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
			log.error("堆垛机处于等待确认且任务完成状态。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			if (crnProtocol.getTaskNo() == 9999) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			@@ -1293,6 +1569,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 {
			@@ -1301,8 +1578,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);

			@@ -1319,7 +1604,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());
			@@ -2001,261 +2286,11 @@

			}

			//RGV搬运
			public synchronized void rgvIoExecute() {
			for (RgvSlave slave : slaveProperties.getRgv()) {
			ZyRgvThread rgvThread = (ZyRgvThread) SlaveConnection.get(SlaveType.Rgv, slave.getId());
			if (rgvThread == null) {
			return;
			}

			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			return;
			}

			// 判断RGV是否空闲
			if (rgvProtocol.getModeType() == RgvModeType.COMPUTER
			&& rgvProtocol.getStatusType() == RgvStatusType.IDLE) {
			// 如果最近一次是入库模式，则优先扫描出库站点
			if (rgvProtocol.getLastIo().equals("I")) {
			this.rgvOutExecute(rgvThread, rgvProtocol);//出库
			rgvProtocol.setLastIo("O");
			}else {
			this.rgvInExecute(rgvThread, rgvProtocol);//入库
			rgvProtocol.setLastIo("I");
			}

			//检查是否存在工位1任务超时没下发
			if (rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() == 0) {
			if (System.currentTimeMillis() - rgvProtocol.getTask1SendTime() > (1000*60)) {
			//工位1下发时间超过60s
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvProtocol.getRgvNo());//RGV编号
			rgvCommand.setCommand((short) 1);//工位1确认
			if (!MessageQueue.offer(SlaveType.Rgv, rgvCommand.getRgvNo(), new Task(4, rgvCommand))) {
			log.error("RGV确认命令下发失败，RGV号={}，任务数据={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
			return;
			}
			log.error("RGV确认命令下发成功，RGV号={}，任务数据={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
			}
			}
			}
			}
			}

			//rgv入库
			public synchronized void rgvInExecute(ZyRgvThread rgvThread, RgvProtocol rgvProtocol) {
			for (RgvSlave.Sta sta : rgvThread.getSlave().getInStn()) {
			if (rgvProtocol.getTaskNo1() > 0) {
			//检测rgv工位1是否为入库任务
			WrkMast wrkMast1 = wrkMastMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
			if (wrkMast1.getWrkSts() > 100) {
			continue;//出库任务跳过
			}
			}

			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, sta.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(sta.getSourceStaNo());
			//判断输送线是否自动、有物、可入、有工作号
			if (!(staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isOutEnable() && (staProtocol.getWorkNo() > 0))) {
			continue;
			}

			//搜索工作档
			WrkMast wrkMast = wrkMastMapper.selectByWrkNo(staProtocol.getWorkNo().intValue());
			if (wrkMast == null) {
			continue;//工作档不存在
			}

			//获取RGV放货站点
			Integer staNo = Utils.getRgvStaNo(rgvProtocol.getRgvNo(), sta.getSourceStaNo(), staProtocol.getStaNo().intValue(), true);
			if (staNo == null) {
			continue;//RGV放货站点不存在
			}

			//判断目标站是否自动、可入、无物、无工作号
			StaProtocol staProtocol1 = devpThread.getStation().get(staNo);
			if (!(staProtocol1.isAutoing() && staProtocol1.isInEnable() && !staProtocol1.isLoading() && (staProtocol1.getWorkNo() == 0))) {
			continue;
			}

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvProtocol.getRgvNo());//RGV编号
			rgvCommand.setAckFinish((short) 0);

			//判断rgv工位1是否可用
			if (rgvProtocol.getTaskNo1() == 0) {
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue());//工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PICK_RELEASE);//工作模式取放货
			rgvCommand.setSourceStaNo1(staProtocol.getStaNo());//源站
			rgvCommand.setDestinationStaNo1(staNo.shortValue());//目标站
			rgvCommand.setCommand((short) 0);//工位1暂不确认
			} else if (rgvProtocol.getTaskNo2() == 0) {//判断rgv工位2是否可用
			rgvCommand.setTaskNo2(wrkMast.getWrkNo().shortValue());//工作号
			rgvCommand.setTaskMode2(RgvTaskModeType.PICK_RELEASE);//工作模式取放货
			rgvCommand.setSourceStaNo2(staProtocol.getStaNo());//源站
			rgvCommand.setDestinationStaNo2(staNo.shortValue());//目标站
			rgvCommand.setCommand((short) 1);//工位2确认
			}else {
			continue;//没有可用RGV工位
			}

			if (!MessageQueue.offer(SlaveType.Rgv, rgvCommand.getRgvNo(), new Task(2, rgvCommand))) {
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
			continue;
			}

			log.error("RGV命令下发成功，RGV号={}，任务数据={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
			}
			}

			//rgv出库
			public synchronized void rgvOutExecute(ZyRgvThread rgvThread, RgvProtocol rgvProtocol) {
			for (RgvSlave.Sta sta : rgvThread.getSlave().getOutStn()) {
			if (rgvProtocol.getTaskNo1() > 0) {
			//检测rgv工位1是否为出库任务
			WrkMast wrkMast1 = wrkMastMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
			if (wrkMast1.getWrkSts() < 100) {
			continue;//入库任务跳过
			}
			}

			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, sta.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(sta.getSourceStaNo());
			//判断输送线是否自动、有物、可出、有工作号
			if (!(staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isOutEnable() && (staProtocol.getWorkNo() > 0))) {
			continue;
			}

			//搜索工作档
			WrkMast wrkMast = wrkMastMapper.selectByWrkNo(staProtocol.getWorkNo().intValue());
			if (wrkMast == null) {
			continue;//工作档不存在
			}

			//获取RGV放货站点
			Integer staNo = Utils.getRgvStaNo(rgvProtocol.getRgvNo(), sta.getSourceStaNo(), staProtocol.getStaNo().intValue(), false);
			if (staNo == null) {
			continue;//RGV放货站点不存在
			}

			//判断目标站是否自动、可出、无物、无工作号
			StaProtocol staProtocol1 = devpThread.getStation().get(staNo);
			if (!(staProtocol1.isAutoing() && staProtocol1.isOutEnable() && !staProtocol1.isLoading() && (staProtocol1.getWorkNo() == 0))) {
			continue;
			}

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvProtocol.getRgvNo());//RGV编号
			rgvCommand.setAckFinish((short) 0);

			//判断rgv工位1是否可用
			if (rgvProtocol.getTaskNo1() == 0) {
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue());//工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PICK_RELEASE);//工作模式取放货
			rgvCommand.setSourceStaNo1(staProtocol.getStaNo());//源站
			rgvCommand.setDestinationStaNo1(staNo.shortValue());//目标站
			rgvCommand.setCommand((short) 0);//工位1暂不确认
			} else if (rgvProtocol.getTaskNo2() == 0) {//判断rgv工位2是否可用
			rgvCommand.setTaskNo2(wrkMast.getWrkNo().shortValue());//工作号
			rgvCommand.setTaskMode2(RgvTaskModeType.PICK_RELEASE);//工作模式取放货
			rgvCommand.setSourceStaNo2(staProtocol.getStaNo());//源站
			rgvCommand.setDestinationStaNo2(staNo.shortValue());//目标站
			rgvCommand.setCommand((short) 1);//工位2确认
			}else {
			continue;//没有可用RGV工位
			}

			if (!MessageQueue.offer(SlaveType.Rgv, rgvCommand.getRgvNo(), new Task(2, rgvCommand))) {
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
			continue;
			}

			log.error("RGV命令下发成功，RGV号={}，任务数据={}", rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
			}
			}

			//RGV工作完成
			public synchronized void rgvFinished() {
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			for (RgvSlave slave : slaveProperties.getRgv()) {
			ZyRgvThread rgvThread = (ZyRgvThread) SlaveConnection.get(SlaveType.Rgv, slave.getId());
			if (rgvThread == null) {
			return;
			}

			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			return;
			}

			// 状态：等待确认
			if (rgvProtocol.getStatusType() == RgvStatusType.WAITING) {
			if (rgvProtocol.getTaskNo1() == 9999) {
			// RGV复位
			rgvThread.setResetFlag1(true);
			}else {
			// 获取待确认工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
			if (wrkMast == null) {
			log.error("RGV处于等待确认且任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgvProtocol.getRgvNo(), rgvProtocol.getTaskNo1());
			continue;
			}

			if (rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskFinish1() == 1) {
			//工位1任务完成
			// RGV复位
			rgvThread.setResetFlag1(true);

			//给目标站输送线写入数据
			Short destinationPos1 = rgvProtocol.getDestinationPos1();//获取工位1目标站
			StaProtocol staProtocol = devpThread.getStation().get(destinationPos1.intValue()).clone();
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());//写入工作号
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());//写入目标站
			if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol))) {
			log.info("{}任务，RGV搬运成功，写入输送数据失败{}", wrkMast.getWrkNo(), JSON.toJSONString(staProtocol));
			}

			//2号RGV和3号RGV工作完成后需要更新工作档状态
			if (rgvProtocol.getRgvNo() == 2 \|\| rgvProtocol.getRgvNo() == 3) {
			if (wrkMast.getWrkSts() == 13) {//13.RGV搬运中 => 14.已出库
			wrkMast.setWrkSts(14L);
			wrkMast.setModiTime(new Date());
			wrkMastMapper.updateById(wrkMast);
			}
			}
			}

			if (rgvProtocol.getTaskNo2() > 0 && rgvProtocol.getTaskFinish2() == 1) {
			//工位2任务完成
			// RGV复位
			rgvThread.setResetFlag2(true);

			//给目标站输送线写入数据
			Short destinationPos2 = rgvProtocol.getDestinationPos2();//获取工位2目标站
			StaProtocol staProtocol = devpThread.getStation().get(destinationPos2.intValue()).clone();
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());//写入工作号
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());//写入目标站
			if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol))) {
			log.info("{}任务，RGV搬运成功，写入输送数据失败{}", wrkMast.getWrkNo(), JSON.toJSONString(staProtocol));
			}

			//2号RGV和3号RGV工作完成后需要更新工作档状态
			if (rgvProtocol.getRgvNo() == 2 \|\| rgvProtocol.getRgvNo() == 3) {
			if (wrkMast.getWrkSts() == 13) {//13.RGV搬运中 => 14.已出库
			wrkMast.setWrkSts(14L);
			wrkMast.setModiTime(new Date());
			wrkMastMapper.updateById(wrkMast);
			}
			}
			}
			}
			}
			}
			}

			/**
			* 扫描碟盘机自动入库空托盘
			@@ -2278,14 +2313,23 @@
			List<StaDesc> staDescs = staDescService.selectList(new EntityWrapper<StaDesc>().eq("type_no", 10).eq("stn_no", sta.getStaNo()));
			for (StaDesc staDesc:staDescs){

			BasDevp basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", staDesc.getCrnStn()));
			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(basDevp.getDevNo().shortValue());
			staProtocol.setStaNo((short) 1013);
			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) {
			@@ -2354,11 +2398,19 @@
			// && staProtocol.isEmptyMk()
			&& staProtocol.getWorkNo() == 0
			) {
			WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(sta.getStaNo());
			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", sta.getStaNo()));

			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){
			@@ -2367,6 +2419,7 @@
			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)
			@@ -2394,4 +2447,1302 @@

			}

			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("修改工作档状态 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;
			Integer matnr = 0;
			Integer 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 RGVTaskOver() {
			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){
			//完成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;
			}



			}

			//工位二任务完成
			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(),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,Integer 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 (code >0 && !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);
			if (Cools.isEmpty(matnrCode)){
			throw new CoolException("未找到对应的物料信息");
			}
			CombParam combParam = new CombParam();
			ArrayList<CombParam.CombMat> combMats = new ArrayList<>();
			CombParam.CombMat combMat = new CombParam.CombMat();
			combParam.setBarcode(barcode);
			combMat.setMatnr(matnrCode.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));
			}
			}

			}