zy-wcs.git - Gitblit

			@@ -19,11 +19,13 @@
			import com.zy.common.service.CommonService;
			import com.zy.common.utils.CollectionUtils;
			import com.zy.common.utils.HttpHandler;
			import com.zy.common.utils.News;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.cache.MessageQueue;
			import com.zy.core.cache.SlaveConnection;
			import com.zy.core.enums.*;
			import com.zy.core.enums.DevpType.DevpWorkType;
			import com.zy.core.model.CrnSlave;
			import com.zy.core.model.DevpSlave;
			import com.zy.core.model.LedSlave;
			@@ -38,18 +40,21 @@
			import com.zy.core.thread.SiemensCrnThread;
			import com.zy.core.thread.SiemensDevpThread;
			import lombok.extern.slf4j.Slf4j;
			import org.apache.poi.ss.formula.functions.T;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			import org.springframework.scheduling.annotation.Async;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;
			import springfox.documentation.spring.web.json.Json;

			import java.util.ArrayList;
			import java.util.Date;
			import java.util.List;
			import java.util.Set;
			import java.util.stream.Collectors;


			/**
			* 立体仓库WCS系统主流程业务
			@@ -94,6 +99,8 @@

			@Value("${test.url}")
			private String testUrl;
			@Autowired
			private WrkMastService wrkMastService;

			/**
			* 组托
			@@ -104,39 +111,76 @@
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历入库口
			for (DevpSlave.Sta inSta : devp.getInSta()) {
			inSta.setStaNo(102);
			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			if (barcodeThread == null) {
			continue;
			}
			String barcode = barcodeThread.getBarcode();
			// barcode="ILY0127 0001";
			if(!Cools.isEmpty(barcode)) {
			log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
			if("NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			continue;
			}
			} else {
			continue;
			}

			// 获取入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			Short workNo = staProtocol.getWorkNo();
			// 尺寸检测异常
			boolean back = false;
			String errMsg = "异常：";
			if (staProtocol.isFrontErr()) {
			errMsg = errMsg+"前超限；";
			back = true;
			}
			if (staProtocol.isBackErr()) {
			errMsg = errMsg+"后超限";
			back = true;
			}
			if (staProtocol.isHighErr()) {
			errMsg = errMsg+"高超限";
			back = true;
			}
			if (staProtocol.isLeftErr()) {
			errMsg = errMsg+"左超限";
			back = true;
			}
			if (staProtocol.isRightErr()) {
			errMsg = errMsg+"右超限";
			back = true;
			}
			if (staProtocol.isWeightErr()) {
			errMsg = errMsg+"超重";
			back = true;
			}
			if (staProtocol.isBarcodeErr()) {
			errMsg = errMsg+"扫码失败";
			back = true;
			}
			// 退回
			if (back) {
			// led 异常显示
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
			if (ledThread != null) {
			MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
			}
			continue;
			}
			String barcode = barcodeThread.getBarcode();
			if (!Cools.isEmpty(barcode)&&!barcode.equals("00000000")) {
			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 ( inSta.getStaNo()==180 && devpThread.ioMode != IoModeType.PAKIN_MODE) { continue; }

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

			// if(Cools.isEmpty(barcode) \|\| "NG".endsWith(barcode) \|\| "NoRead".equals(barcode)) {
			@@ -155,18 +199,17 @@
			// 判断重复工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
			if (wrkMast != null) {
			log.error("工作档中已存在该站状态为（ 2.设备上走）的数据,工作号={}", wrkMast.getWrkNo());
			News.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;
			// }
			// 获取入库通知档
			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);
			locTypeDto.setLocType1((short)1);
			SearchLocParam param = new SearchLocParam();
			@@ -174,6 +217,7 @@
			param.setIoType(1);
			param.setSourceStaNo(inSta.getStaNo());
			param.setLocType1(locTypeDto.getLocType1());
			// param.setPackNo(pack);
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/rpc/pakin/loc/v1")
			@@ -183,92 +227,34 @@
			JSONObject jsonObject = JSON.parseObject(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);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			News.error("更新plc站点信息失败");
			throw new CoolException("更新plc站点信息失败");
			}
			} else if (jsonObject.getInteger("code").equals(700) && (!barcodeThread.getBarcode().equals("NG"))){
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);
			barcodeThread.setBarcode("");
			staProtocol.setWorkNo((short)9998);
			staProtocol.setStaNo((short)101);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			staProtocol.setWorkNo((short)9991);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), true);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			log.error("url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}else {
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);
			barcodeThread.setBarcode("");
			staProtocol.setWorkNo((short)9998);
			staProtocol.setStaNo((short)101);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			staProtocol.setWorkNo((short)9991);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), true);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
			}


			// // 检索库位
			// 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站点信息失败");
			// }

			} catch (Exception e) {
			News.error("扫码入库报错，错误信息",e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			@@ -325,7 +311,7 @@
			log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			} else {
			log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
			}

			}
			@@ -487,7 +473,7 @@
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && (staProtocol.isLoading()\|\|staProtocol.getSiteId()==109) && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == null)) {
			if (staProtocol.isAutoing() && (staProtocol.isLoading()\|\|staProtocol.getSiteId()==1000) && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == null)) {
			// 查询工作档
			WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId());
			if (wrkMast == null) {
			@@ -495,6 +481,7 @@
			}
			// 判断工作档条件
			if (wrkMast.getIoType() < 100 \|\| wrkMast.getStaNo() == null \|\| wrkMast.getSourceStaNo() == null) {
			News.error("工作档案条件不满足：工作档案："+wrkMast+";条件iotype<100或者staNo为空或者sourceStaNo为空");
			continue;
			}
			// 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
			@@ -525,7 +512,7 @@
			// 复位堆垛机
			crnThread.setResetFlag(true);
			} else {
			log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			News.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
			}

			}
			@@ -546,7 +533,7 @@
			if (crnProtocol == null) { continue; }
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			News.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}

			@@ -662,7 +649,7 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
			@@ -681,11 +668,11 @@
			// 获取库位信息
			LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
			if (locMast == null) {
			log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			News.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
			continue;
			}
			if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
			log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			News.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
			continue;
			}

			@@ -707,12 +694,12 @@
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			waitWrkMast.setIoPri(15D);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			continue;
			}
			@@ -748,10 +735,14 @@
			crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(locMast.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层
			crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层\
			crnCommand.setBarcode(wrkMast.getBarcode());//托盘码
			log.error("768 堆垛机命令下发"+crnCommand);
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			log.error("772 堆垛机命令下发成功"+crnCommand);
			News.info("772 堆垛机命令下发成功"+crnCommand);

			// long startTime = System.currentTimeMillis();
			// while ((System.currentTimeMillis() - startTime) < COMMAND_TIMEOUT) {
			@@ -766,13 +757,17 @@
			// }

			// 修改工作档状态 2.设备上走 => 3.吊车入库中
			log.error("787 修改工作档状态2.设备上走 => 3.吊车入库中 "+wrkMast);
			News.info("787 修改工作档状态2.设备上走 => 3.吊车入库中 "+wrkMast);
			Date now = new Date();
			wrkMast.setWrkSts(3L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			log.error("795 修改工作档状态成功2.设备上走 => 3.吊车入库中"+wrkMast);
			News.info("795 修改工作档状态成功2.设备上走 => 3.吊车入库中"+wrkMast);
			}
			}
			}
			@@ -792,13 +787,13 @@
			}
			// 工作档状态判断
			if (wrkMast.getIoType() < 100 \|\| wrkMast.getSourceStaNo() == null){
			log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			News.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
			continue;
			}
			// 获取源库位信息
			LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
			if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
			log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
			continue;
			}
			// 获取堆垛机出库站信息
			@@ -817,60 +812,25 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			break;
			// continue;
			}
			// 判断堆垛机出库站状态
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
			&& staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
			// 命令下发区 --------------------------------------------------------------------------
			//查询在库信息
			LocMast locMast =locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("loc_sts","R")
			.eq("loc_no",wrkMast.getSourceLocNo()));
			if(Cools.isEmpty(locMast)){
			News.error("出库 ===>> 库位中没有这笔资料",wrkMast.getSourceLocNo());
			continue;
			}

			//消防报警出库
			if(wrkMast.getStaNo()==1000&& locMast.getCtnKind()==1){
			// 堆垛机控制过滤
			if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			// continue;
			break;
			}

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			if(waitWrkMast.getWrkSts() == 11) {
			waitWrkMast.setIoPri(15D);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			continue;
			} else {

			}
			}
			} else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			// 此标记避免多次执行移库任务
			if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())
			\|\| Cools.isEmpty(waitWrkMast)) {
			wrkMast.setUpdMk("Y");
			wrkMastMapper.updateById(wrkMast);
			// 生成工作档,将浅库位移转到新的库位中
			moveLocForDeepLoc(slave, shallowLoc);
			}
			log.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
			continue;
			} else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")){
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (null != waitWrkMast && waitWrkMast.getWrkSts()==4) {
			continue;
			}
			}
			}

			// 已经存在吊车执行任务时，则过滤
			@@ -891,8 +851,9 @@
			crnCommand.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			crnCommand.setBarcode(wrkMast.getBarcode());
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			Date now = new Date();
			@@ -900,9 +861,101 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			break;
			}
			}else {
			// 判断堆垛机出库站状态
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
			&& staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
			//测试库位出库必须要按启动按钮才能出库
			if((wrkMast.getStaNo()==206 \|\| wrkMast.getStaNo()==1000)&& locMast.getCtnKind()==0){
			News.error("出库 ===>> 等待启动出库按钮",wrkMast);
			continue;
			}
			// 命令下发区 --------------------------------------------------------------------------

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

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			// O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用直接搬！
			if (shallowLoc.getLocSts().equals("P") \|\| shallowLoc.getLocSts().equals("R")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (null == waitWrkMast) {
			News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
			} else {
			if(waitWrkMast.getWrkSts() == 11) {
			waitWrkMast.setIoPri(15D);
			waitWrkMast.setModiTime(new Date());
			if (wrkMastMapper.updateById(waitWrkMast) == 0) {
			News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
			}
			continue;
			} else {

			}
			}
			} else if (shallowLoc.getLocSts().equals("F") \|\| shallowLoc.getLocSts().equals("D")) {
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			// 此标记避免多次执行移库任务
			if (Cools.isEmpty(wrkMast.getUpdMk()) \|\| "N".equals(wrkMast.getUpdMk())
			\|\| Cools.isEmpty(waitWrkMast)) {
			wrkMast.setUpdMk("Y");
			wrkMastMapper.updateById(wrkMast);
			// 生成工作档,将浅库位移转到新的库位中
			moveLocForDeepLoc(slave, shallowLoc);
			}
			News.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
			continue;
			} else if (shallowLoc.getLocSts().equals("Q") \|\| shallowLoc.getLocSts().equals("S")){
			WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
			if (null != waitWrkMast && waitWrkMast.getWrkSts()==4) {
			continue;
			}
			}
			}

			// 已经存在吊车执行任务时，则过滤
			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(sourceSta.getRow1().shortValue()); // 源库位排
			crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列
			crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层
			crnCommand.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			crnCommand.setBarcode(wrkMast.getBarcode());
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			News.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) {
			News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			break;
			}
			}
			}
			}
			@@ -1030,15 +1083,42 @@
			* 库位移转
			*/
			public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
			// log.info("开始移库任务程序");
			//获取所有移库任务
			List<WrkMast> wrkMasts=wrkMastMapper.selectLocMoves(slave.getId());
			// 获取工作档信息
			WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
			if (null == wrkMast) {
			WrkMast wrkMast =null;
			if(Cools.isEmpty(wrkMasts)){
			return;
			}
			//先查测试库位转OK或者NG库位按了按钮的
			for (WrkMast wm: wrkMasts) {
			LocMast sourceSta1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wm.getSourceLocNo()));
			if (!Cools.isEmpty(sourceSta1.getCtnKind())){
			if(sourceSta1.getCtnKind()==1){
			wrkMast=wm;
			break;
			}
			}
			}
			//后查等待库位转测试库位
			if(Cools.isEmpty(wrkMast)){
			for (WrkMast wm: wrkMasts) {
			LocMast sourceSta1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wm.getSourceLocNo()));
			if (sourceSta1.getLocType1()==3){
			wrkMast=wm;
			}
			}
			}
			//都没有满足条件的，跳过移库
			if(Cools.isEmpty(wrkMast)){
			return;
			}

			// 获取源库位信息
			LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
			if (null == sourceSta) {
			log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return;
			}
			// 源库位库位状态判断
			@@ -1048,7 +1128,7 @@
			// 获取目标库位信息
			LocMast sta = locMastService.selectById(wrkMast.getLocNo());
			if (null == sta) {
			log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
			return;
			}
			// 获取堆垛机信息并判断是否可入出
			@@ -1067,6 +1147,12 @@
			return;
			}

			//测试库位出库必须要按启动按钮才能出库
			if(sourceSta.getLocType1()==1 && sourceSta.getCtnKind()==0){
			News.error("出库 ===>> 等待启动按钮",wrkMast);
			return;
			}

			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			@@ -1079,8 +1165,13 @@
			crnCommand.setDestinationPosX(sta.getRow1().shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(sta.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(sta.getLev1().shortValue()); // 目标库位层
			if(!sta.getLocNo().equals("0102501")){
			crnCommand.setBarcode(wrkMast.getBarcode());//托盘码
			}else {
			crnCommand.setFireStaut((short) 1);
			}
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			Date now = new Date();
			@@ -1088,9 +1179,10 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("【库位移转】修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("【库位移转】修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			log.info("结束移库任务程序");

			}

			@@ -1113,7 +1205,7 @@
			// 获取入库待确认工作档
			WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
			if (wrkMast == null) {
			log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			continue;
			}
			// 入库 + 库位转移 ==> 4.入库完成
			@@ -1382,7 +1474,7 @@
			* 出库 ===>> 工作档信息写入led显示器
			*/
			@Async
			public void ledExecute() {
			public synchronized void ledExecute() {
			for (LedSlave led : slaveProperties.getLed()) {
			// 获取输送线plc线程
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
			@@ -1393,20 +1485,27 @@
			for (Integer staNo : led.getStaArr()) {
			// 获取叉车站点
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			if (null == staProtocol \|\| null == staProtocol.getWorkNo() \|\| 0 == staProtocol.getWorkNo() \|\| !staProtocol.isLoading()) {
			if (null == staProtocol \|\| null == staProtocol.getWorkNo() \|\| 0 == staProtocol.getWorkNo()) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			// 获取工作档数据
			WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
			if (null == wrkMast \|\| wrkMast.getWrkSts() < 14 \|\| wrkMast.getIoType() < 100) { continue; }
			if (null == wrkMast) { continue; }
			wrkMasts.add(wrkMast);
			// 组装命令
			LedCommand ledCommand = new LedCommand();
			ledCommand.setWorkNo(wrkMast.getWrkNo());
			ledCommand.setIoType(wrkMast.getIoType());
			// 出库模式
			switch (wrkMast.getIoType()) {
			case 1:
			ledCommand.setTitle("全板入库");
			break;
			case 10:
			ledCommand.setTitle("空板入库");
			break;
			case 101:
			ledCommand.setTitle("全板出库");
			break;
			@@ -1424,16 +1523,39 @@
			ledCommand.setEmptyMk(true);
			break;
			default:
			log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
			News.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
			break;
			}
			ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
			ledCommand.setStaNo(wrkMast.getStaNo());
			if (wrkMast.getIoType() != 110) {
			ledCommand.setBarcode(wrkMast.getBarcode());
			if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
			List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
			wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme())));

			wrkDetls.forEach(wrkDetl -> {
			Double total = 0.0;
			EntityWrapper<LocDetl> wrapper = new EntityWrapper<>();
			LocDetl locDetl = locDetlService.selectOne(wrapper.eq("zpallet", wrkDetl.getZpallet()).eq("matnr", wrkDetl.getMatnr()));
			if (Cools.isEmpty(locDetl)) {
			total = wrkDetl.getAnfme();
			} else {
			total = locDetl.getAnfme();
			}
			if (wrkMast.getIoType() == 101 \|\| wrkMast.getIoType() == 1) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
			}
			if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() \|\| 0 == wrkDetl.getInspect())) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
			}
			if (wrkMast.getIoType() == 107 \|\| wrkMast.getIoType() == 104) {
			ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
			}
			});
			}
			commands.add(ledCommand);
			}
			if(Cools.isEmpty(wrkMasts)){
			continue;
			}
			Set<Integer> workNos = wrkMasts.stream().map(WrkMast::getWrkNo).collect(Collectors.toSet());
			// 获取LED线程
			@@ -1445,10 +1567,8 @@
			// 命令下发 -------------------------------------------------------------------------------
			if (!commands.isEmpty()) {
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			News.error("{}号LED显示内容命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			continue;
			} else {
			ledThread.setLedMk(false);
			}
			}

			@@ -1524,12 +1644,12 @@
			// 获取led线程
			LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
			// led显示默认内容
			if (reset && !ledThread.isLedMk()) {
			ledThread.setLedMk(true);
			if (reset) {
			if (ledThread == null) {
			continue;
			}
			if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
			log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			} else {

			News.error("{}号LED显示默认命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			}
			}
			}
			@@ -1849,15 +1969,15 @@
			if (wrkMast == null) { continue; }
			// 入库
			if (wrkMast.getWrkSts() == 1 \|\| wrkMast.getWrkSts() == 2) {
			log.warn("堆垛机非空闲情况下，开始修改工作档状态。[id:{},时间：{}] >>>>> 堆垛机当前状态为：{}。任务号:{}", crn.getId(), DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), crnProtocol.getStatusType().desc, crnProtocol.getTaskNo());
			News.warn("堆垛机非空闲情况下，开始修改工作档状态。[id:{},时间：{}] >>>>> 堆垛机当前状态为：{}。任务号:{}", crn.getId(), DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), crnProtocol.getStatusType().desc, crnProtocol.getTaskNo());
			// 修改工作档状态 2.设备上走 => 3.吊车入库中
			wrkMast.setWrkSts(3L);
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			log.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}", DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), wrkMast.getWrkNo());
			News.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}", DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), wrkMast.getWrkNo());
			}
			// 出库、移库
			if (wrkMast.getWrkSts() == 11) {
			@@ -1867,9 +1987,9 @@
			wrkMast.setCrnStrTime(now);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			log.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}", DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), wrkMast.getWrkNo());
			News.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}", DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), wrkMast.getWrkNo());
			}


			@@ -1943,7 +2063,7 @@
			// 查询站点详细信息
			BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
			if (staDetl == null) {
			log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
			continue;
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
			@@ -1988,7 +2108,7 @@
			crnCommand.setDestinationPosY((short)19); // 目标库位列
			crnCommand.setDestinationPosZ((short)1); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", 1, JSON.toJSON(crnCommand));
			News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", 1, JSON.toJSON(crnCommand));
			} else {
			}
			}
			@@ -2008,171 +2128,207 @@
			int olsStatus = 0;//testMast表原来status数据状态
			int newStatus = 0;//testMast表待修改的status数据状态
			short newSingle = 0; //PLC地址待修改的新值
			switch (devpThread.startSignal[i]){//根据信号查找testMast表中对应状态条件,olsStatus，newStatus根据实际流程调整
			case 1://启动复核信号
			olsStatus = 2;
			newStatus = 3;
			newSingle = 2;//测试复核，寄存器地址，1===>>2
			switch (devpThread.startSignal[i][0]){//根据信号查找testMast表中对应状态条件,olsStatus，newStatus根据实际流程调整
			case 0://初始状态，入库
			olsStatus = 1;//待测
			newStatus = 1;//待测
			newSingle = 1;//库存有资料，寄存器地址，0===>>1
			break;
			case 2://完成测试信号
			olsStatus = 3;
			newStatus = 3;
			newSingle = 3;//测试完成，寄存器地址清零，2===>>3
			case 4://完成测试信号
			olsStatus = 3;
			newStatus = 4;
			newSingle = 0;//测试完成，寄存器地址清零，4===>>0
			case 2://启动复核信号
			olsStatus = 1;//待测
			newStatus = 2;//复核中
			newSingle = 3;//测试复核，寄存器地址，2===>>3
			break;
			case 5://暂停信号
			case 3://测试完成
			olsStatus = 4;//测试完成
			newStatus = 4;//测试完成
			newSingle = 4;//（NG:4\OK:41）测试完成，寄存器地址，3===>>4\41
			break;
			case 5://NG测试信号
			case 6://完成测试信号
			case 22://完成测试信号
			olsStatus = 4;//测试完成
			newStatus = 5;//已移库
			newSingle = 0;//启动移库，寄存器地址清零，5/6===>>0
			break;
			case 7://暂停信号
			olsStatus = 99;//plc给出暂停信号
			newStatus = 0;//WCS收到暂停信号后，更新testMast
			newSingle = 6;//暂停测试，寄存器地址，5===>>6
			newSingle = 8;//暂停测试，寄存器地址，7===>>8
			break;
			case 7://紧急出库确认充电线已经拔出
			case 9://紧急出库确认充电线已经拔出
			olsStatus = 99;//plc给出暂停信号
			newStatus = 0;//WCS收到暂停信号后，更新testMast
			newSingle = 6;//暂停测试，寄存器地址，7===>>6
			newSingle = 8;//暂停测试，寄存器地址，9===>>8
			break;
			case 8://解除暂停
			olsStatus = 99;
			newStatus = 0;
			newSingle = 0;//测试复核，寄存器地址，8===>>0
			case 10://解除暂停信号
			olsStatus = 0;//plc给出暂停信号
			newStatus = 1;//WCS收到暂停信号后，更新testMast
			newSingle = 0;//暂停测试，寄存器地址，10===>>0/11
			break;
			case 11://入库前判断充电线是否放好
			olsStatus = 99;
			newStatus = 0;
			newSingle = 11;//
			case 12://紧急出库确认充电线已经拔出
			newSingle = 11;//暂停测试，寄存器地址，12===>>11
			break;
			case 12://充电线放好
			olsStatus = 99;
			newStatus = 0;
			newSingle = 0;//测试复核，寄存器地址，12===>>0
			case 13://入库前判断充电线是否放好
			newSingle = 14;//禁用库位，寄存器地址，13===>>14
			break;
			case 15://充电线放好
			newSingle = 0;//复位，寄存器地址，12===>>0
			break;
			default:
			log.info("读取通道"+(i+1)+"测试库位按钮信号:为"+devpThread.startSignal[i][0]);
			continue;
			}

			TestMast testMast = testMastService.selectOne(new EntityWrapper<TestMast>()
			.eq("channel",(i+1)).eq("status",olsStatus));//查找原来的状态
			if(null != testMast &&
			(devpThread.startSignal[i] == 1 \|\| devpThread.startSignal[i] == 3)){
			testMast.setStatus(newStatus);
			testMast.setModiTime(new Date());
			if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
			.eq("channel",(i+1)).eq("status",olsStatus))){
			throw new CoolException("更新产品测试状态失败");
			}
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,1==>2或3==>0,5==>6
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			if(!result){
			log.error("更新测试信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, testMast.getLocNo(), testMast.getBarcode());
			// throw new CoolException("更新测试信号失败===>>" + i);
			} else {
			devpThread.startSignal[i] = newSingle;
			}
			}else if (null != testMast && devpThread.startSignal[i] == 2){
			if (testMast.getStatus()==3){
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			if (locMast.getLocSts().equals("F") && locMast.getPackStatus()==3){
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,2==>3
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			if(!result){
			log.error("更新测试信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, testMast.getLocNo(), testMast.getBarcode());
			// throw new CoolException("更新测试信号失败===>>" + i);
			} else {
			devpThread.startSignal[i] = newSingle;
			LocMast locMast=null;
			boolean sign=false;
			switch (devpThread.startSignal[i][0]){
			case 0:
			if (!Cools.isEmpty(testMast)){
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F")){
			sign=true;
			}
			}
			}
			}else if (devpThread.startSignal[i] == 5){
			SearchLocParam param = new SearchLocParam();
			param.setBarcode(i+1+"");
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/mobile/test/suspend/auth")
			.setJson(JSON.toJSONString(param))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,5==>6
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			if(!result){
			log.error("暂停测试失败===>>["+i+1+"]号通道");
			// throw new CoolException("更新测试信号失败===>>" + i);
			} else {
			devpThread.startSignal[i] = newSingle;
			break;
			case 3:
			if (!Cools.isEmpty(testMast)){
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F")){
			sign=true;
			if (locMast.getPackStatus()==3){//测试完成
			newSingle=41;
			}else if (locMast.getPackStatus()==4){//测试失败
			newSingle=4;
			}else {
			log.info("读取通道"+(i+1)+"测试库位按钮信号:为"+devpThread.startSignal[i][0]+"通道库位pack状态信息异常"+locMast.getPackStatus());
			sign=false;
			}
			}
			}
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/mobile/test/suspend/auth", JSON.toJSONString(param), response);
			}
			}else if (devpThread.startSignal[i] == 7){
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			if (locMast.getLocSts().equals("F")){
			locMast.setPackStatus(8); //8.紧急出库
			locMastService.update(locMast,new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			}
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,7==>6
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			break;
			case 5:
			case 6:
			if (!Cools.isEmpty(testMast)){
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F")){
			if (devpThread.startSignal[i][0]==5 && locMast.getPackStatus()==4){
			sign=true;
			}else if (devpThread.startSignal[i][0]==6 && locMast.getPackStatus()==3){
			sign=true;
			}else {
			log.error("测试完成移库时按下完成按钮与测试结果不一致===>>[channel:{}", i+1);
			}
			}else {
			log.error("测试完成移库时未查询到测试档案===>>[channel:{}", i+1);
			}
			}
			break;
			case 2:
			if (!Cools.isEmpty(testMast)){
			testMast.setStatus(newStatus);
			testMast.setModiTime(new Date());
			if(!testMastService.update(testMast,new EntityWrapper<TestMast>().eq("channel",(i+1)).eq("barcode",testMast.getBarcode()))){
			throw new CoolException("更新产品测试状态失败");
			}else {
			sign=true;
			}
			}else {
			log.error("启动测试时未查询到测试档案===>>[channel:{}", i+1);
			}
			break;
			case 7:
			SearchLocParam param = new SearchLocParam();
			param.setBarcode(i+1+"");
			String response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath("/mobile/test/suspend/auth")
			.setJson(JSON.toJSONString(param))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			testMast = testMastService.selectOne(new EntityWrapper<TestMast>().eq("channel",(i+1)));
			testMast.setStatus(newStatus);
			testMast.setModiTime(new Date());
			if(!testMastService.update(testMast,new EntityWrapper<TestMast>().eq("channel",(i+1)).eq("barcode",testMast.getBarcode()))){
			log.error("更新产品测试状态失败");
			}
			sign=true;
			} else {
			log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/mobile/test/suspend/auth", JSON.toJSONString(param), response);
			}
			break;
			case 9:
			case 12:
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F") \|\| locMast.getLocSts().equals("D")){
			locMast.setPackStatus(8); //8.紧急出库
			if (locMastService.update(locMast,new EntityWrapper<LocMast>().eq("channel",(i+1)))){
			log.info("库位：{}，紧急出库！",locMast.getLocNo());
			}
			}else {
			log.error("库位不是在库状态，无需紧急出库！");
			}
			sign=true;
			break;
			case 10:
			if (!Cools.isEmpty(testMast)){
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F") ){
			if ( locMast.getFireStatus().equals(1)){
			newSingle=11;
			}else {
			testMast.setStatus(newStatus);
			testMast.setModiTime(new Date());
			if(!testMastService.update(testMast,new EntityWrapper<TestMast>().eq("channel",(i+1)).eq("barcode",testMast.getBarcode()))){
			throw new CoolException("更新产品测试状态失败");
			}else {
			sign=true;
			}
			}
			}
			}
			sign=true;
			break;
			case 13:
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (locMast.getLocSts().equals("O")){
			locMast.setLocSts("X");
			locMastService.update(locMast,new EntityWrapper<LocMast>().eq("channel",(i+1)));
			}
			sign=true;
			break;
			case 15:
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if (locMast.getLocSts().equals("X")){
			locMast.setLocSts("O");
			locMastService.update(locMast,new EntityWrapper<LocMast>().eq("channel",(i+1)));
			}
			sign=true;
			break;
			default:
			log.info("读取通道"+(i+1)+"测试库位按钮信号:为"+devpThread.startSignal[i][0]);
			continue;
			}
			if (sign){
			boolean result = messageQueueOffer(i,newSingle,SlaveType.Devp, devp.getId());
			if(!result){
			log.error("更新库位紧急出库信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, locMast.getLocNo(), locMast.getBarcode());
			// throw new CoolException("更新测试信号失败===>>" + i);
			log.error("更新测试信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, testMast.getLocNo(), testMast.getBarcode());
			} else {
			devpThread.startSignal[i] = newSingle;
			devpThread.startSignal[i][0] = newSingle;
			}
			}else if (devpThread.startSignal[i] == 8){
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,8==>0
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			if(!result){
			// log.error("更新库位紧急出库信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, locMast.getLocNo(), locMast.getBarcode());
			// throw new CoolException("更新测试信号失败===>>" + i);
			} else {
			devpThread.startSignal[i] = newSingle;
			}
			try{
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
			if(devpThread.startSignal[i][1]!=locMast.getFireStatus()){
			messageQueueOffer2(i+1,(short)((int)locMast.getFireStatus()),SlaveType.Devp, devp.getId());
			}
			}else if (devpThread.startSignal[i] == 11){
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			if (locMast.getLocSts().equals("O")){
			locMast.setLocSts("X");
			locMastService.update(locMast,new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			}
			}else if (devpThread.startSignal[i] == 12){
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			if (locMast.getLocSts().equals("X")){
			locMast.setLocSts("O");
			locMastService.update(locMast,new EntityWrapper<LocMast>()
			.eq("channel",(i+1)));
			}
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,12==>0
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			if(!result){
			// log.error("更新库位紧急出库信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, locMast.getLocNo(), locMast.getBarcode());
			// throw new CoolException("更新测试信号失败===>>" + i);
			} else {
			devpThread.startSignal[i] = newSingle;
			}
			}else { }
			}catch (Exception e){
			log.error("火警 ===>> 给输送线发送警报失败,通道号：", i+1);
			}
			}

			}
			@@ -2185,6 +2341,22 @@
			}
			}

			public boolean messageQueueOffer(int i ,short newSingle,SlaveType devp,Integer id){
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i*2);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,8==>0
			return MessageQueue.offer(devp, id, new Task(3, staProtocol));
			}

			public boolean messageQueueOffer2(int i ,short newSingle,SlaveType devp,Integer id){
			//复位PLC信号，借用输送站点实体类
			StaProtocol staProtocol = new StaProtocol();
			staProtocol.setSiteId(i);//寄存器地址
			staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,8==>0
			return MessageQueue.offer(devp, id, new Task(5, staProtocol));
			}

			/**
			* 将火警报警信号写入到堆垛机PLC中
			*/
			@@ -2192,27 +2364,215 @@
			public void fierCrn() {
			try {
			for (CrnSlave crn :slaveProperties.getCrn()) {
			if(crn.getId()!=1){
			continue;
			}
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("fire_status", 1));
			if (!Cools.isEmpty(locMast)){
			//报警信号写入1
			if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, (short)1))) {
			log.error("火警 ===>> 给堆垛机发送报警信号失败");
			if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, 1))) {
			News.error("火警 ===>> 给堆垛机发送报警信号失败");
			}
			News.error("火警!!!!!!! ===>> 给堆垛机发送报警信号成功");
			} else {
			//报警信号没有后，复位地址
			if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, (short)0))) {
			log.error("火警 ===>> 给堆垛机清零复位报警信号失败");
			if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, 0))) {
			News.error("火警 ===>> 给堆垛机清零复位报警信号失败");
			}
			}
			}
			} catch (Exception e) {
			log.error("火警 ===>> 给堆垛机发送警报失败", e);
			News.error("火警 ===>> 给堆垛机发送警报失败", e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}

			/**
			* 103站点有物下发pack码
			*/
			@Transactional
			public void packDevp() {
			try {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			BasDevp basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no",103));
			if (Cools.isEmpty(basDevp)){
			News.error("103站点查询失败-MainServiceImpl.java-2255行");
			}
			if (basDevp.getAutoing().equals("Y") && basDevp.getWrkNo()>0 && basDevp.getLoading().equals("Y") ){
			WrkDetl wrkDetl = wrkDetlService.devpPackNo(basDevp.getWrkNo());
			if (Cools.isEmpty(wrkDetl)){
			News.error("103站点查询失败-MainServiceImpl.java-2255行");
			}
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4,wrkDetl.getMatnr()));
			}
			}
			} catch (Exception e) {
			News.error("103 ===>> 给输送线发送Pack码失败", e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}
			/**
			* 根据PLC按钮测试、完成、暂停信号，更新testMast表中status值，交由WMS系统处理
			*/
			@Transactional
			public void packTest1() {
			try {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			log.info("2363行程序开始运行");
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			if(null != devpThread){
			for (int i = 0; i < 48; i++){
			// log.info("2367行程序开始运行，第"+i+"次");
			boolean fig=false;
			//查询在库和预约出库
			LocMast locMast=locMastService.selectztgx("F","R",i);
			if(!Cools.isEmpty(locMast)){
			// log.info("2372行程序开始运行，查询测试档");
			TestMast testMast=testMastService.selectOne(new EntityWrapper<TestMast>()
			.eq("loc_no",locMast.getLocNo())
			.eq("user_id",locMast.getBarcode()));
			if(Cools.isEmpty(testMast)){
			// log.info("2377行程序开始运行，测试档为空，跳过");
			continue;
			}
			// log.info("2380行程序开始运行，测试档不为空，下一步");
			//devpThread.startSignal[i][0]
			//0:空,1:启动中,2:工作中,3:自动暂停,4:正常完成(OK),5:异常停止(NG),6:在线,7:离线,8:空闲

			//locMast.setPackStatus
			// "产品状态{0:无,1:待测,2:测试中;3.测试完成;4.测试失败;5.静置中;6:静置完成;7:暂停测试;8:紧急出库;9:在线;10:离线;11:空闲;}"

			//testMast.setStatus
			//"状态 0: 待申请 1: 申请中 2: 已复核 3:测试中 4:完成 5:移库 6:火警"
			if(devpThread.startSignal[i][0]==8){
			News.info("2390行程序开始运行，修改测试档状态为 1、申请中，开始修改前："+ JSON.toJSONString(testMast));
			testMast.setStatus(1);
			locMast.setPackStatus(1);
			testMast.setModiTime(new Date());
			log.info("2394行程序开始运行，修改测试档状态为 1、申请中,修改数据后、未更新"+JSON.toJSONString(testMast));
			}else if(devpThread.startSignal[i][0]==2 && locMast.getPackStatus()!=2){
			News.info("2396行程序开始运行，修改测试档状态为 3、测试中，开始修改前："+JSON.toJSONString(testMast));
			testMast.setStatus(3);
			locMast.setPackStatus(2);
			testMast.setModiTime(new Date());
			log.info("2400，修改测试档状态为 3、测试中,修改数据后、未更新"+JSON.toJSONString(testMast));
			//NG转OK需要还原源库位和目标库位状态，OK转NG 删除任务档
			WrkMast wrkMast=wrkMastService.selectOne(new EntityWrapper<WrkMast>()
			.eq("source_loc_no",locMast.getLocNo())
			.eq("wrk_sts",11));
			News.info("2405，查询状态为生成出库id的测试完成（NG或OK）任务档，"+JSON.toJSONString(wrkMast));
			if(!Cools.isEmpty(wrkMast)){
			if(wrkMast.getWrkSts()==11){
			if(wrkMast.getIoType()==11){
			log.info("2409，删除任务档为移库的，"+JSON.toJSONString(wrkMast));
			LocMast locMast1=locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wrkMast.getLocNo()));
			locMast1.setLocSts("O");
			locMastService.update(locMast1,new EntityWrapper<LocMast>().eq("loc_no",wrkMast.getLocNo()));
			}
			wrkMastMapper.deleteById(wrkMast);
			log.info("2415，删除工作档"+JSON.toJSONString(wrkMast)+JSON.toJSONString(locMast));
			locMast.setLocSts("F");
			log.info("2417，删除工作档"+JSON.toJSONString(wrkMast)+JSON.toJSONString(locMast));
			wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no",wrkMast.getWrkNo()));
			log.info("2419，删除工作明细"+wrkMast.getWrkNo());
			if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
			.eq("channel",i+1))){
			log.error("2422修改测试库位状态失败"+locMast.getLocNo()+JSON.toJSONString(locMast));
			}else{
			log.error("2424修改测试库位状态成功"+locMast.getLocNo()+JSON.toJSONString(locMast));
			fig=true;
			}
			}
			}
			}else if(devpThread.startSignal[i][0]==3){
			locMast.setPackStatus(7);
			testMast.setModiTime(new Date());
			}else if(devpThread.startSignal[i][0]==4 && testMast.getStatus()!=4&&locMast.getFireStatus()!=1&&testMast.getStatus()!=6){
			locMast.setPackStatus(3);
			testMast.setStatus(4);
			testMast.setModiTime(new Date());
			testMastService.insertPackQualified(true,new Date(),testMast.getBarcode());
			}else if(devpThread.startSignal[i][0]==5 && testMast.getStatus()!=4&&locMast.getFireStatus()!=1&&testMast.getStatus()!=6){
			locMast.setPackStatus(4);
			testMast.setStatus(4);
			testMast.setModiTime(new Date());
			testMastService.insertPackQualified(false,new Date(),testMast.getBarcode());
			}
			// else if(devpThread.startSignal[i][0]==6\|\|devpThread.startSignal[i][0]==7\|\|devpThread.startSignal[i][0]==8){
			// locMast.setPackStatus(devpThread.startSignal[i][0]+3);
			// }
			//通道启动按钮状态，1:可以启动出库或者移库，0:不能启动出库或者移库
			locMast.setCtnKind(devpThread.startSignal[i][2]);
			if(devpThread.startSignal[i][2]==1){
			if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
			.eq("loc_sts","R")
			.eq("channel",i+1))){
			News.error("修改启动按钮状态，测试库位状态失败"+locMast.getLocNo(),locMast);
			}
			}else if(!locMast.getLocSts().equals("R")){
			if(!fig){
			if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
			.eq("loc_sts","F")
			.eq("channel",i+1))){
			News.error("修改测试库位状态失败"+locMast.getLocNo(),locMast);
			}
			}
			if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
			.eq("loc_no",locMast.getLocNo())
			.eq("user_id",locMast.getBarcode()))) {
			News.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
			}
			}
			}
			}
			//当充放电库位为O空库位时
			//库位状态改为8空闲
			//给PLC写消防信号
			for (int i=0;i<48;i++){
			LocMast locMast=locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",i+1));
			TestMast testMast=testMastService.selectOne(new EntityWrapper<TestMast>()
			.eq("loc_no",locMast.getLocNo())
			.eq("user_id",locMast.getBarcode()));
			if((locMast.getLocSts().equals("O")\|\|locMast.getLocSts().equals("S"))&&devpThread.startSignal[i][0]!=8){
			Thread.sleep(1000);
			MessageQueue.offer(SlaveType.Devp, 1, new Task(6,locMast.getChannel()-1));
			}
			try{
			if(locMast.getFireStatus()!=devpThread.startSignal[i][1]){
			messageQueueOffer2(i,(short)((int)locMast.getFireStatus()),SlaveType.Devp, devp.getId());
			if(Cools.isEmpty(testMast)){
			continue;
			}
			if(locMast.getFireStatus()==1){
			testMast.setStatus(6);//火警
			if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
			.eq("loc_no",locMast.getLocNo())
			.eq("user_id",locMast.getBarcode()))) {
			News.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
			}
			}
			}
			}catch (Exception e){
			News.error("火警 ===>> 给输送线发送警报失败,通道号：", i+1);
			}
			}



			}

			}
			} catch (Exception e) {
			News.error("获得测试库位状态失败", e);
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}
			}