zy-wcs.git - Gitblit

			@@ -8,11 +8,9 @@
			import com.core.common.DateUtils;
			import com.core.exception.CoolException;
			import com.zy.asrs.entity.*;
			import com.zy.asrs.mapper.BasCrnErrorMapper;
			import com.zy.asrs.mapper.BasRgvErrMapper;
			import com.zy.asrs.mapper.WaitPakinMapper;
			import com.zy.asrs.mapper.WrkMastMapper;
			import com.zy.asrs.mapper.*;
			import com.zy.asrs.service.*;
			import com.zy.asrs.utils.RouteUtils;
			import com.zy.asrs.utils.Utils;
			import com.zy.asrs.utils.VersionUtils;
			import com.zy.common.model.LocTypeDto;
			@@ -22,6 +20,8 @@
			import com.zy.common.service.CommonService;
			import com.zy.common.utils.CollectionUtils;
			import com.zy.common.utils.HttpHandler;
			import com.zy.common.utils.RedisUtil;
			import com.zy.common.utils.RgvUtils;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.cache.MessageQueue;
			@@ -69,6 +69,8 @@
			@Autowired
			private WrkDetlService wrkDetlService;
			@Autowired
			private WaitPakinMapper waitPakinMapper;
			@Autowired
			private LocMastService locMastService;
			@Autowired
			private StaDescService staDescService;
			@@ -88,6 +90,14 @@
			private BasRgvErrMapper basRgvErrMapper;
			@Autowired
			private BasRgvErrLogService basRgvErrLogService;
			@Autowired
			private BasRgvPathService basRgvPathService;
			@Autowired
			private RedisUtil redisUtil;
			@Autowired
			private WrkMastStaMapper wrkMastStaMapper;
			@Autowired
			private BasRgvMapMapper basRgvMapMapper;

			@Value("${wms.url}")
			private String wmsUrl;
			@@ -187,12 +197,12 @@
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			barcodeThread.setBarcode("");
			staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			staProtocol.setWorkNo(dto.getWorkNo());

			if(Cools.isEmpty(dto.getRgvNo()) \|\| dto.getRgvNo() <= 0) {
			staProtocol.setStaNo(dto.getStaNo().shortValue());
			staProtocol.setStaNo(dto.getStaNo());
			} else {//如果存在RGV编号，说明需要RGV接驳，先下发任务到RGV源站
			staProtocol.setStaNo(dto.getRgvSstaNo().shortValue());
			staProtocol.setStaNo(dto.getRgvSstaNo());
			}

			devpThread.setPakMk(staProtocol.getSiteId(), false);
			@@ -253,8 +263,8 @@
			// 命令下发区 --------------------------------------------------------------------------

			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (result) {
			@@ -383,8 +393,8 @@
			}

			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			@@ -438,8 +448,8 @@
			// 命令下发区 --------------------------------------------------------------------------

			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			@@ -465,57 +475,273 @@
			* 入出库 ===>> 堆垛机入出库作业下发
			*/
			public synchronized void crnIoExecute() {
			for (CrnSlave crn : slaveProperties.getCrn()) {
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) {
			continue;
			}
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}
			try{
			for (CrnSlave crn : slaveProperties.getCrn()) {
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) {
			continue;
			}
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}

			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE
			&& crnProtocol.getTaskNo() == 0
			&& crnProtocol.getModeType() == CrnModeType.AUTO
			&& crnProtocol.getLoaded() == 0
			&& crnProtocol.getForkPos() == 0) {
			// 如果最近一次是入库模式
			if (crnProtocol.getLastIo().equals("I")) {
			if (basCrnp.getInEnable().equals("Y")) {
			this.crnStnToLoc1(crn, crnProtocol); // 入库
			crnProtocol.setLastIo("O");
			} else if (basCrnp.getOutEnable().equals("Y")) {
			this.locToCrnStn1(crn, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE
			&& crnProtocol.getTaskNo() == 0
			&& crnProtocol.getModeType() == CrnModeType.AUTO
			&& crnProtocol.getLoaded() == 0
			&& crnProtocol.getForkPos() == 0) {
			// 如果最近一次是入库模式
			if (crnProtocol.getLastIo().equals("I")) {
			if (basCrnp.getInEnable().equals("Y")) {
			this.crnStnToLoc1(crn, crnProtocol); // 入库
			crnProtocol.setLastIo("O");
			} else if (basCrnp.getOutEnable().equals("Y")) {
			this.locToCrnStn1(crn, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			}
			}
			// 如果最近一次是出库模式
			else if (crnProtocol.getLastIo().equals("O")) {
			if (basCrnp.getOutEnable().equals("Y")) {
			this.locToCrnStn1(crn, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			} else if (basCrnp.getInEnable().equals("Y")) {
			this.crnStnToLoc1(crn, crnProtocol); // 入库
			crnProtocol.setLastIo("O");
			}
			}
			}
			// 如果最近一次是出库模式
			else if (crnProtocol.getLastIo().equals("O")) {
			if (basCrnp.getOutEnable().equals("Y")) {
			this.locToCrnStn1(crn, crnProtocol); // 出库
			crnProtocol.setLastIo("I");
			} else if (basCrnp.getInEnable().equals("Y")) {
			this.crnStnToLoc1(crn, crnProtocol); // 入库
			crnProtocol.setLastIo("O");
			}
			}
			}
			// 库位移转
			this.locToLoc(crn, crnProtocol);
			// 库位移转
			this.locToLoc(crn, crnProtocol);
			// this.crnRebackHp(crnProtocol, crnThread);

			}
			}catch (Exception e){
			log.error("堆垛机出入库下发报错"+e);
			}
			}

			/**
			* 搜索RGV车。通过目标站搜索哪台车可用
			*/
			public synchronized Integer searchRgvNo(Integer staNo) {
			try{
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			return null;//目标站不存在
			}
			//路径值
			int path = basDevp.getLocType3().intValue();

			ArrayList<RgvThread> list = new ArrayList<>();
			for (RgvSlave rgv : slaveProperties.getRgv()) {
			// 获取RGV信息
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {

			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgv.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgv.getId());
			continue;
			}

			list.add(rgvThread);
			}

			if (list.size() > 1) {
			//超过两台车，按照配置的规则进行分配
			for (RgvThread rgvThread : list) {
			//获取车辆配置的路径规则
			BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(rgvThread.getSlave().getId());
			if (basRgvPath == null) {
			continue;
			}
			//目标站是否包含当前路径中
			List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
			if (rgvPath.contains(path)) {
			//当前路径中包含目标站，则选定这台车
			return rgvThread.getSlave().getId();
			}
			}
			}else {
			//小于或等于1台车，分配全路径
			BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(0);//获取默认路径
			if (basRgvPath == null) {
			return null;
			}
			List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
			if (rgvPath.contains(path)) {
			//当前路径中包含目标站，则选定这台车
			return list.get(0).getSlave().getId();
			}
			}

			return null;
			}catch (Exception e){
			log.error("搜索RGV车。通过目标站搜索哪台车可用"+e);
			return null;
			}
			}

			// /**
			// * 绑定小车方法
			// */
			// public synchronized void rgvBindSte() {
			// //获取等待绑定RGV的任务
			// List<WrkMast> wrkMasts = wrkMastMapper.selectWaitBindRGV();
			// for (WrkMast wrkMast : wrkMasts) {
			// //目标站
			// Integer staNo = wrkMast.getStaNo();
			// //源站
			// Integer sourceStaNo = wrkMast.getSourceStaNo();
			// //通过目标站搜索rgv号
			// Integer rgvNo=0;
			// if (wrkMast.getCrnNo()==1){
			// rgvNo=1;
			// }else if (wrkMast.getCrnNo()==6){
			// rgvNo=2;
			// }else {
			// rgvNo = this.searchRgvNo(staNo);
			// }
			// if (rgvNo == null \|\| rgvNo==0) {//未找到可用的rgv
			// continue;
			// }
			//
			// wrkMast.setRgvNo(rgvNo);//绑定rgv号
			// wrkMast.setRgvDstaNo(wrkMast.getSourceStaNo());//设置RGV前往工作档源站取货
			// if (wrkMastMapper.updateById(wrkMast)==0){
			// log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			// }
			// }
			// }

			/**
			* 绑定小车方法
			*/
			public synchronized void rgvBindSte() {
			try {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			if (devp.getId()==2){
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			//入库绑小车
			for (DevpSlave.Sta Sta : devp.getInRgvSta()) {
			StaProtocol staProtocol = devpThread.getStation().get(Sta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() != 0 && staProtocol.getWorkNo() < 9990){
			List<WrkMast> wrkMasts = wrkMastMapper.selectList(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getWorkNo()).eq("wrk_sts", 2L));
			if (Cools.isEmpty(wrkMasts) \|\| wrkMasts.size()!=1){
			continue;
			}
			WrkMast wrkMast = wrkMasts.get(0);
			//目标站
			Integer staNo = wrkMast.getStaNo();
			//通过目标站搜索rgv号
			Integer rgvNo=0;
			if (wrkMast.getCrnNo()==1){
			rgvNo=1;
			}else if (wrkMast.getCrnNo()==6){
			rgvNo=2;
			}else {
			rgvNo = this.searchRgvNo(staNo);
			}
			if (rgvNo == null \|\| rgvNo==0) {//未找到可用的rgv
			continue;
			}
			wrkMast.setRgvNo(rgvNo);//绑定rgv号
			if (wrkMastMapper.updateById(wrkMast)==0){
			log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			}
			}
			//出库绑小车
			for (DevpSlave.Sta Sta : devp.getOutRgvSta()) {
			StaProtocol staProtocol = devpThread.getStation().get(Sta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() != 0 && staProtocol.getWorkNo() < 9990){
			List<WrkMast> wrkMasts = wrkMastMapper.selectList(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getWorkNo()).eq("wrk_sts", 14L));
			if (Cools.isEmpty(wrkMasts) \|\| wrkMasts.size()!=1){
			continue;
			}
			WrkMast wrkMast = wrkMasts.get(0);
			//目标站
			Integer staNo = wrkMast.getStaNo();
			//通过目标站搜索rgv号
			Integer rgvNo=0;
			if (wrkMast.getCrnNo()==1){
			rgvNo=1;
			}else if (wrkMast.getCrnNo()==6){
			rgvNo=2;
			}else {
			rgvNo = this.searchRgvNo(staNo);
			}
			if (rgvNo == null \|\| rgvNo==0) {//未找到可用的rgv
			continue;
			}
			wrkMast.setRgvNo(rgvNo);//绑定rgv号
			if (wrkMastMapper.updateById(wrkMast)==0){
			log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			}
			}
			}
			}catch (Exception e){
			log.error("绑定小车异常：{}", e.getMessage());
			}
			}

			/**
			* 绑定小车方法
			*/
			public synchronized void rgvBindSte() {
			public synchronized void rgvBindSte2() {
			try{
			for (RgvSlave rgv : slaveProperties.getRgv()) {
			List<WrkMast> wrkMasts = wrkMastMapper.selectWaitBindRGVRgvNo(rgv.getId());
			if (!Cools.isEmpty(wrkMasts) && wrkMasts.size()!=0){
			continue;
			}
			List<WrkMast> wrkMasts2 = wrkMastMapper.selectWaitBindRgvNo2(rgv.getId());
			for (WrkMast wrkMast : wrkMasts2) {
			if (wrkMastMapper.selectWaitBindRgvNoOneWrkNo(wrkMast.getWrkNo())!=null){
			continue;
			}
			//目标站
			BasDevp basDevp = basDevpService.selectById(wrkMast.getRgvDstaNo());
			if (Cools.isEmpty(basDevp) \|\| !basDevp.getAutoing().equals("Y") \|\| !basDevp.getLoading().equals("N") \|\| basDevp.getWrkNo()!=0){
			continue;
			}
			wrkMastMapper.insertRgvMast(wrkMast.getWrkNo());
			wrkMastMapper.updateRgvMast(wrkMast.getWrkNo());
			break;
			}
			}
			}catch (Exception e){
			log.error("小车搬运任务异常：{}", e.getMessage());
			}
			}

			/**
			* 入出库 ===>> RGV入出库作业下发
			*/
			public synchronized void rgvIoExecuteOld() {
			for (RgvSlave rgv : slaveProperties.getRgv()) {
			// 获取RGV信息
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
			@@ -529,123 +755,441 @@
			continue;
			}

			// 只有当RGV空闲、自动, 并且无任务、无物时才继续执行
			// 只有当RGV空闲、自动,
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
			&& rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
			// && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
			// && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
			) {
			// 如果最近一次是入库模式
			if (rgvProtocol.getLastIo().equals("I")) {
			if (basRgv.getInEnable().equals("Y")) {
			this.rgvBindSteIn(rgv, rgvProtocol); // 入库
			rgvProtocol.setLastIo("O");
			} else if (basRgv.getOutEnable().equals("Y")) {
			this.rgvBindSteOut(rgv, rgvProtocol); // 出库
			rgvProtocol.setLastIo("I");

			//查找是否存在入出库工作中等待RGV搬运的任务
			List<WrkMast> wrkMasts = wrkMastMapper.selectIoRgvNo(rgv.getId());
			for (WrkMast wrkMast : wrkMasts) {
			if (wrkMast.getWrkSts() == 2) {//2.设备上走1 => 3.RGV取货中
			if (rgvProtocol.getTaskNo1() != 0 \|\| rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getSourceStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			// boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式: 取货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 2.设备上走1 => 3.RGV取货中
			Date now = new Date();
			wrkMast.setWrkSts(3L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 2.设备上走1 => 3.RGV取货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else if (wrkMast.getWrkSts() == 14) {//4.RGV取货完成 => 5.RGV放货中 14出库完成
			if (rgvProtocol.getTaskNo1() == 0 \|\| !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
			continue;
			}
			if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 4.RGV取货完成 => 5.RGV放货中
			Date now = new Date();
			wrkMast.setWrkSts(5L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 4.RGV取货完成 => 5.RGV放货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else if (wrkMast.getWrkSts() == 23) {//23.设备上走1 => 24.RGV取货中
			if (rgvProtocol.getTaskNo1() != 0 \|\| rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getSourceStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式: 取货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 23.设备上走1 => 24.RGV取货中
			Date now = new Date();
			wrkMast.setWrkSts(24L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 23.设备上走1 => 24.RGV取货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else if (wrkMast.getWrkSts() == 25) {//25.RGV取货完成 => 26.RGV放货中
			if (rgvProtocol.getTaskNo1() == 0 \|\| !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
			continue;
			}
			if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 25.RGV取货完成 => 26.RGV放货中
			Date now = new Date();
			wrkMast.setWrkSts(26L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 25.RGV取货完成 => 26.RGV放货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			// 如果最近一次是出库模式
			else if (rgvProtocol.getLastIo().equals("O")) {
			if (basRgv.getOutEnable().equals("Y")) {
			this.rgvBindSteOut(rgv, rgvProtocol); // 出库
			rgvProtocol.setLastIo("I");
			} else if (basRgv.getInEnable().equals("Y")) {
			this.rgvBindSteIn(rgv, rgvProtocol); // 入库
			rgvProtocol.setLastIo("O");
			}
			}

			}
			}
			}

			/**
			* 绑定小车入库方法
			*/
			public synchronized void rgvBindSteIn(RgvSlave slave, RgvProtocol rgvProtocol) {
			for (RgvSlave.RgvStn rgvStn: slave.getRgvInSStn()){
			Integer staNo = rgvStn.getStaNo();
			BasDevp basDevp = basDevpService.selectById(rgvStn.getDevpPlcId());
			if (Cools.isEmpty(basDevp) \|\| basDevp.getWrkNo()==0){
			continue;
			}else {
			WrkMast wrkMast = wrkMastMapper.selectRgvInSteWrkNo(basDevp.getWrkNo());
			if (!Cools.isEmpty(wrkMast)){
			wrkMast.setRgvNo(wrkMast.getCrnNo()>3 ? 2 : 1);
			wrkMast.setAppeTime(new Date());
			if (wrkMastMapper.updateById(wrkMast)==0){
			log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			}
			}
			}
			}

			/**
			* 绑定小车出库方法
			*/
			public synchronized void rgvBindSteOut(RgvSlave slave, RgvProtocol rgvProtocol) {
			for (RgvSlave.RgvStn rgvStn: slave.getRgvOutSStn()){
			BasDevp basDevp = basDevpService.selectById(rgvStn.getDevpPlcId());
			if (Cools.isEmpty(basDevp) \|\| basDevp.getWrkNo()==0){
			continue;
			}else {
			WrkMast wrkMast = wrkMastMapper.selectRgvOutSteWrkNo(basDevp.getWrkNo());
			if (!Cools.isEmpty(wrkMast)){
			wrkMast.setRgvNo(rgvStn.getStaNo());
			wrkMast.setAppeTime(new Date());
			if (wrkMastMapper.updateById(wrkMast)==0){
			log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
			}
			}
			}
			}
			}
			/**
			* 入出库 ===>> RGV入出库作业下发
			*/
			public synchronized void rgvIoExecute() {
			for (RgvSlave rgv : slaveProperties.getRgv()) {
			RgvSlave rgvSlave=null;
			if (rgv.getId()==1){
			rgvSlave = slaveProperties.getRgv().get(1);
			}else {
			rgvSlave = slaveProperties.getRgv().get(0);
			}

			// 获取RGV信息
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}

			RgvThread rgvThreadSlave = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocolSlave = rgvThreadSlave.getRgvProtocol();
			BasRgv basRgvSlave = null;
			if (rgvProtocolSlave == null) {
			rgvSlave=null;
			}else {
			basRgvSlave = basRgvService.selectById(rgv.getId());
			if (basRgvSlave == null) {
			rgvSlave=null;
			}
			}

			BasRgv basRgv = basRgvService.selectById(rgv.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgv.getId());
			continue;
			}

			// 只有当RGV空闲、自动, 并且无任务、无物时才继续执行
			boolean signSlave=false;//此处判断RgvSlave是否已经规避
			boolean signSlaveState=false;//此处判断RgvSlave是否空闲
			Integer staSlave = 0;//此处记录RgvSlave当前位置

			// 只有当RGV空闲、自动,
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
			&& rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
			// && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
			// && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
			) {
			// 如果最近一次是入库模式
			if (rgvProtocol.getLastIo().equals("I")) {
			if (basRgv.getInEnable().equals("Y")) {
			this.rgvInStn(rgv, rgvProtocol); // 入库
			rgvProtocol.setLastIo("O");
			} else if (basRgv.getOutEnable().equals("Y")) {
			this.rgvOutStn(rgv, rgvProtocol); // 出库
			rgvProtocol.setLastIo("I");

			//查找是否存在入出库工作中等待RGV搬运的任务
			List<WrkMast> wrkMasts = wrkMastMapper.selectIoRgvNo(rgv.getId());
			for (WrkMast wrkMast : wrkMasts) {
			if (wrkMast.getWrkSts() == 2) {//2.设备上走1 => 3.RGV取货中
			if (rgvProtocol.getTaskNo1() != 0 \|\| rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getSourceStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			// boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式: 取货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 2.设备上走1 => 3.RGV取货中
			Date now = new Date();
			wrkMast.setWrkSts(3L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 2.设备上走1 => 3.RGV取货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else if (wrkMast.getWrkSts() == 14) {//4.RGV取货完成 => 5.RGV放货中 14出库完成
			if (rgvProtocol.getTaskNo1() == 0 \|\| !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
			continue;
			}
			if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 4.RGV取货完成 => 5.RGV放货中
			Date now = new Date();
			wrkMast.setWrkSts(5L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 4.RGV取货完成 => 5.RGV放货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else if (wrkMast.getWrkSts() == 23) {//23.设备上走1 => 24.RGV取货中
			if (rgvProtocol.getTaskNo1() != 0 \|\| rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getSourceStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式: 取货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 23.设备上走1 => 24.RGV取货中
			Date now = new Date();
			wrkMast.setWrkSts(24L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 23.设备上走1 => 24.RGV取货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			} else if (wrkMast.getWrkSts() == 25) {//25.RGV取货完成 => 26.RGV放货中
			if (rgvProtocol.getTaskNo1() == 0 \|\| !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
			continue;
			}
			if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
			continue;
			}

			//判断行走路径是否被占用
			Integer staNo = wrkMast.getStaNo();
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp == null) {
			continue;//目标站不存在
			}
			//起始路径
			int startPath = rgvProtocol.getRgvPos().intValue();
			//目标路径值
			int endPath = basDevp.getLocType3().intValue();
			boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
			if (pathUsed) {
			//行走路径被占用，禁止下发命令
			continue;
			}
			//行走路径空闲，锁定路径
			RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 25.RGV取货完成 => 26.RGV放货中
			Date now = new Date();
			wrkMast.setWrkSts(26L);
			wrkMast.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 25.RGV取货完成 => 26.RGV放货中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			}
			}
			}
			// 如果最近一次是出库模式
			else if (rgvProtocol.getLastIo().equals("O")) {
			if (basRgv.getOutEnable().equals("Y")) {
			this.rgvOutStn(rgv, rgvProtocol); // 出库
			rgvProtocol.setLastIo("I");
			} else if (basRgv.getInEnable().equals("Y")) {
			this.rgvInStn(rgv, rgvProtocol); // 入库
			rgvProtocol.setLastIo("O");
			}
			}

			}
			}
			}

			private boolean rgvIoExecuteWrk2To3() {
			return false;
			}

			/**
			@@ -1332,6 +1876,9 @@
			* 入库 ===>> RGV入库站到站
			*/
			public synchronized void rgvInStn(RgvSlave slave, RgvProtocol rgvProtocol) {
			WrkMast wrkMast = wrkMastMapper.selectRgvInSteNo(slave.getId());


			//查找工作状态为2（设备上走）,且RGV入库接驳站符合的的入库工作档，提取出最多2笔
			List<WrkMast> wrkMastTask = getRgvInTask(slave);
			if(wrkMastTask.size() <= 0){
			@@ -1595,6 +2142,7 @@
			* 根据RGV完成信号，执行对工作档的完成操作，和RGV的任务下发
			*/
			public synchronized void rgvFinished() {
			Date now = new Date();
			for (RgvSlave rgv : slaveProperties.getRgv()) {
			// 获取RGV信息
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
			@@ -1602,133 +2150,176 @@
			if (rgvProtocol == null) {
			continue;
			}
			// 工位1状态：取货完成等待确认91 并且任务完成位 = 1
			if (rgvProtocol.statusType1 == RgvStatusType.FETCHWAITING && rgvProtocol.getTaskNo1() != 0) {
			//工位1取货完成后，工位2是无货空闲状态时，准备给工位2发任务，确认是否有待执行RGV任务
			if (rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() == 0
			&& rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() == 0
			&& rgvProtocol.getStatusType2() == RgvStatusType.IDLE
			) {
			WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
			if (wrkMast1 == null) {
			log.error("RGV工位1处于等待确认且取货任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgv.getId(), rgvProtocol.getTaskNo1());
			continue;
			}
			List<WrkMast> wrkMastTask = new ArrayList<>();
			List<WrkMast> list = new ArrayList<>();
			Integer type = 0;//1入库，2出库
			if(wrkMast1.getWrkSts()==6L){
			wrkMastTask = getRgvInTask(rgv);
			list = wrkMastMapper.selectRgvInWorking(rgv.getId());
			type = 1;
			} else if(wrkMast1.getWrkSts()==16L){
			wrkMastTask = getRgvOutTask(rgv);
			list = wrkMastMapper.selectRgvOutWorking(rgv.getId());
			type = 2;
			}
			if(wrkMastTask.size() > 0){//有继续执行任务，下发取货任务给工位2
			// 已经存在RGV执行任务时，则过滤
			if (list.size() > 1) {
			continue;
			}
			WrkMast wrkMast2 = wrkMastTask.get(0);
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			rgvCommand.setAckFinish2((short) 0); // 工位2任务完成确认位
			rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
			rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式: 取货
			rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue()); //工位2源站点
			rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue()); //工位2目标站点
			rgvCommand.setCommand((short) 0); //工位1、2任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast2.getRgvNo(), new Task(5, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 2.设备上走 => 6.RGV入库取货中
			Date now = new Date();
			wrkMast2.setWrkSts(type==1 ? 6L : 16L);
			wrkMast2.setCrnStrTime(now);
			wrkMast2.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast2) == 0) {
			log.error("工位2修改工作档状态 2/14.设备上走 => 6/16.RGV入库取货中失败！！，工作号={}", wrkMast2.getWrkNo());
			}
			}
			} else {//没有继续执行任务，下发放货任务给工位1
			if(type == 1 && wrkMast1.getWrkSts() != 6L){//RGV入库取货中
			continue;
			}
			if(type == 2 && wrkMast1.getWrkSts() != 16L){//RGV出库取货中
			continue;
			}

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue()); //工位1源站点
			rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 0); //工位1、2任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2任务确认； step=4，工位1确认； step=5，工位2任务确认
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 6.RGV入库取货中 => 7.RGV入库放货中
			Date now = new Date();
			wrkMast1.setWrkSts(type==1 ? 7L : 17L);
			wrkMast1.setCrnEndTime(now);
			wrkMast1.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast1) == 0) {
			log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中失败！！，工作号={}", wrkMast1.getWrkNo());
			}
			log.error("RGV命令下发成功，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			}
			}
			} else if (rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() > 0
			&& rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() > 0
			&& rgvProtocol.statusType2 == RgvStatusType.FETCHWAITING){
			// 工位2状态：也是取货完成等待确认91 并且任务完成位 = 1, 工位1、2同时下发放货任务
			WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
			WrkMast wrkMast2 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo2().intValue());
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue()); //工位1源站点
			rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue()); //工位1目标站点
			rgvCommand.setAckFinish2((short) 0); // 工位2任务完成确认位
			rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
			rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式: 放货
			rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue()); //工位2源站点
			rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue()); //工位2目标站点
			rgvCommand.setCommand((short) 0); //工位1、2任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
			//step=2,工位1、2任务确认； step=4，工位1确认； step=5，工位2任务确认
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			} else {
			// 修改工作档状态 2.设备上走 => 6.RGV入库取货中
			Date now = new Date();
			wrkMast1.setWrkSts(wrkMast1.getWrkSts()==6L ? 7L : 17L);
			wrkMast1.setCrnStrTime(now);
			wrkMast1.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast1) == 0) {
			log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中失败！！，工作号={}", wrkMast1.getWrkNo());
			}

			wrkMast2.setWrkSts(wrkMast2.getWrkSts()==6L ? 7L : 17L);
			wrkMast2.setCrnStrTime(now);
			wrkMast2.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast2) == 0) {
			log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中失败！！，工作号={}", wrkMast2.getWrkNo());
			}
			}
			//判断RGV是否空闲，工位1是否空闲，工位1是否有物，是否为电脑模式，工位1是否有工作号
			if (rgvProtocol.statusType1 == RgvStatusType.FETCHWAITING
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getTaskNo1() != 0
			&& rgvProtocol.getStatus() != 0
			&& rgvProtocol.getStatus1() != 0
			) {
			WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
			if (wrkMast1 == null) {
			log.error("RGV工位1处于等待确认且取货任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgv.getId(), rgvProtocol.getTaskNo1());
			continue;
			}

			if (wrkMast1.getWrkSts() == 3) {//3.RGV取货中 => 4.RGV取货完成
			wrkMast1.setWrkSts(4L);
			}else if(wrkMast1.getWrkSts() == 5){//5.RGV放货中 => 6.RGV放货完成
			rgvProtocol.setTaskNo1((short) 0);//入库任务完成，清空任务号
			wrkMast1.setWrkSts(6L);
			} else if (wrkMast1.getWrkSts() == 24) {//24.RGV取货中 => 25.RGV取货完成
			wrkMast1.setWrkSts(25L);//
			} else if (wrkMast1.getWrkSts() == 26) {//26.RGV放货中 => 27.RGV放货完成
			rgvProtocol.setTaskNo1((short) 0);//出库任务完成，清空任务号
			wrkMast1.setWrkSts(27L);//27.RGV放货完成
			}

			//解锁路径
			RgvUtils.unLockPath(wrkMast1.getRgvNo());

			wrkMast1.setModiTime(now);
			if (wrkMastMapper.updateById(wrkMast1) == 0) {
			log.error("工位1修改工作档状态失败！！，工作号={}", wrkMast1.getWrkNo());
			}

			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			rgvCommand.setAckFinish1((short) 1); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.NONE); // 工位1任务模式: 无
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
			//step=2,工位1、2任务确认； step=4，工位1确认； step=5，工位2任务确认
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			}

			// //工位1取货完成后，工位2是无货空闲状态时，准备给工位2发任务，确认是否有待执行RGV任务
			// if (rgvProtocol.getModeType() == RgvModeType.AUTO
			// && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() == 0
			// && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() == 0
			// && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
			// ) {
			// WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
			// if (wrkMast1 == null) {
			// log.error("RGV工位1处于等待确认且取货任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgv.getId(), rgvProtocol.getTaskNo1());
			// continue;
			// }
			// List<WrkMast> wrkMastTask = new ArrayList<>();
			// List<WrkMast> list = new ArrayList<>();
			// Integer type = 0;//1入库，2出库
			// if(wrkMast1.getWrkSts()==6L){
			// wrkMastTask = getRgvInTask(rgv);
			// list = wrkMastMapper.selectRgvInWorking(rgv.getId());
			// type = 1;
			// } else if(wrkMast1.getWrkSts()==16L){
			// wrkMastTask = getRgvOutTask(rgv);
			// list = wrkMastMapper.selectRgvOutWorking(rgv.getId());
			// type = 2;
			// }
			// if(wrkMastTask.size() > 0){//有继续执行任务，下发取货任务给工位2
			// // 已经存在RGV执行任务时，则过滤
			// if (list.size() > 1) {
			// continue;
			// }
			// WrkMast wrkMast2 = wrkMastTask.get(0);
			// // 命令下发区 --------------------------------------------------------------------------
			// RgvCommand rgvCommand = new RgvCommand();
			// rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			// rgvCommand.setAckFinish2((short) 0); // 工位2任务完成确认位
			// rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
			// rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式: 取货
			// rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue()); //工位2源站点
			// rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue()); //工位2目标站点
			// rgvCommand.setCommand((short) 0); //工位1、2任务确认
			// if (!MessageQueue.offer(SlaveType.Crn, wrkMast2.getRgvNo(), new Task(5, rgvCommand))) {
			// //step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			// log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			// } else {
			// // 修改工作档状态 2.设备上走 => 6.RGV入库取货中
			// Date now = new Date();
			// wrkMast2.setWrkSts(type==1 ? 6L : 16L);
			// wrkMast2.setCrnStrTime(now);
			// wrkMast2.setModiTime(now);
			// if (wrkMastMapper.updateById(wrkMast2) == 0) {
			// log.error("工位2修改工作档状态 2/14.设备上走 => 6/16.RGV入库取货中失败！！，工作号={}", wrkMast2.getWrkNo());
			// }
			// }
			// } else {//没有继续执行任务，下发放货任务给工位1
			// if(type == 1 && wrkMast1.getWrkSts() != 6L){//RGV入库取货中
			// continue;
			// }
			// if(type == 2 && wrkMast1.getWrkSts() != 16L){//RGV出库取货中
			// continue;
			// }
			//
			// // 命令下发区 --------------------------------------------------------------------------
			// RgvCommand rgvCommand = new RgvCommand();
			// rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			// rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			// rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
			// rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			// rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue()); //工位1源站点
			// rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue()); //工位1目标站点
			// rgvCommand.setCommand((short) 0); //工位1、2任务确认
			// if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
			// //step=2,工位1、2任务确认； step=4，工位1确认； step=5，工位2任务确认
			// log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			// } else {
			// // 修改工作档状态 6.RGV入库取货中 => 7.RGV入库放货中
			// Date now = new Date();
			// wrkMast1.setWrkSts(type==1 ? 7L : 17L);
			// wrkMast1.setCrnEndTime(now);
			// wrkMast1.setModiTime(now);
			// if (wrkMastMapper.updateById(wrkMast1) == 0) {
			// log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中失败！！，工作号={}", wrkMast1.getWrkNo());
			// }
			// log.error("RGV命令下发成功，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			// }
			// }
			// } else if (rgvProtocol.getModeType() == RgvModeType.AUTO
			// && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() > 0
			// && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() > 0
			// && rgvProtocol.statusType2 == RgvStatusType.FETCHWAITING){
			// // 工位2状态：也是取货完成等待确认91 并且任务完成位 = 1, 工位1、2同时下发放货任务
			// WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
			// WrkMast wrkMast2 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo2().intValue());
			// // 命令下发区 --------------------------------------------------------------------------
			// RgvCommand rgvCommand = new RgvCommand();
			// rgvCommand.setRgvNo(rgv.getId()); // RGV编号
			// rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			// rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
			// rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			// rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue()); //工位1源站点
			// rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue()); //工位1目标站点
			// rgvCommand.setAckFinish2((short) 0); // 工位2任务完成确认位
			// rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
			// rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式: 放货
			// rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue()); //工位2源站点
			// rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue()); //工位2目标站点
			// rgvCommand.setCommand((short) 0); //工位1、2任务确认
			// if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
			// //step=2,工位1、2任务确认； step=4，工位1确认； step=5，工位2任务确认
			// log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
			// } else {
			// // 修改工作档状态 2.设备上走 => 6.RGV入库取货中
			// Date now = new Date();
			// wrkMast1.setWrkSts(wrkMast1.getWrkSts()==6L ? 7L : 17L);
			// wrkMast1.setCrnStrTime(now);
			// wrkMast1.setModiTime(now);
			// if (wrkMastMapper.updateById(wrkMast1) == 0) {
			// log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中失败！！，工作号={}", wrkMast1.getWrkNo());
			// }
			//
			// wrkMast2.setWrkSts(wrkMast2.getWrkSts()==6L ? 7L : 17L);
			// wrkMast2.setCrnStrTime(now);
			// wrkMast2.setModiTime(now);
			// if (wrkMastMapper.updateById(wrkMast2) == 0) {
			// log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中失败！！，工作号={}", wrkMast2.getWrkNo());
			// }
			// }
			// }
			}

			}
			@@ -1768,8 +2359,8 @@
			&& rgvProtocol.statusType1 == RgvStatusType.WAITING) {
			// 命令下发区 --------------------------------------------------------------------------
			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			@@ -1789,8 +2380,8 @@
			&& rgvProtocol.statusType2 == RgvStatusType.WAITING) {
			// 命令下发区 --------------------------------------------------------------------------
			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			@@ -1844,8 +2435,8 @@
			&& rgvProtocol.statusType1 == RgvStatusType.WAITING) {
			// 命令下发区 --------------------------------------------------------------------------
			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			@@ -1865,8 +2456,8 @@
			&& rgvProtocol.statusType2 == RgvStatusType.WAITING) {
			// 命令下发区 --------------------------------------------------------------------------
			// 下发站点信息
			staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
			staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
			continue;
			}
			@@ -2289,8 +2880,8 @@
			StartupDto dto = jsonObject.getObject("data", StartupDto.class);

			// 更新站点信息且下发plc命令
			staProtocol.setWorkNo(dto.getWorkNo().shortValue());
			staProtocol.setStaNo(dto.getStaNo().shortValue());
			staProtocol.setWorkNo(dto.getWorkNo());
			staProtocol.setStaNo(dto.getStaNo());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			if (!result) {
			@@ -2303,64 +2894,7 @@
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}


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

			}


			}
			}
			}
			@@ -2719,6 +3253,27 @@
			}

			/**
			* 初始化RGV地图
			*/
			public synchronized void initRgvMap() {
			Object data = redisUtil.get("rgv_map");
			if (data == null) {
			//重新获取全路径地图
			BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(0);//获取默认路径
			if (basRgvPath != null) {
			ArrayList<RgvNode> rgvNodes = new ArrayList<>();
			List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
			for (Integer integer : rgvPath) {
			RgvNode rgvNode = new RgvNode(integer);
			rgvNodes.add(rgvNode);
			}
			//将数据库地图数据存入redis
			redisUtil.set("rgv_map", JSON.toJSONString(rgvNodes));
			}
			}
			}

			/**
			* 堆垛机演示 ===>> 库位移转
			*/
			public synchronized void crnDemoOfLocMove1() {
			@@ -3022,4 +3577,795 @@
			}
			}
			}

			// /**
			// * 其他 ===>> 码垛位自动补充空板：驱动拆盘机输出托盘
			// */
			// public synchronized void dischargingMachineOutputTray() {
			// try {
			// List<WrkMast> wrkMasts = wrkMastMapper.selectDischargingMachineOutputTray();
			// if (Cools.isEmpty(wrkMasts) \|\| wrkMasts.size()>3){
			// return;
			// }
			//
			// // 获取入库站信息
			// SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			// StaProtocol staProtocol = devpThread.getStation().get(213);
			// if (staProtocol == null) {
			// log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点查询失败");
			// return;
			// } else {
			// staProtocol = staProtocol.clone();
			// }
			//
			// if (!staProtocol.isLoading()){
			// log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点无物，正在自动调出空板！");
			// int i = wrkMastMapper.selectConfigCount10468N();
			// if (i==1){
			// wrkMastMapper.updateConfig10468Y();
			// }
			// return;
			// }else {
			// int i = wrkMastMapper.selectConfigCount10468N();
			// if (i==0){
			// return;
			// }
			// }
			// StaProtocol staProtocol214 = devpThread.getStation().get(214);
			// // 判断是否满足入库条件
			// if (staProtocol.isAutoing() && staProtocol.getWorkNo() == 0 && staProtocol.isPakMk() && staProtocol214.getWorkNo()==0) {
			// staProtocol.setWorkNo((short)9999);
			// staProtocol.setStaNo((short)214);
			// devpThread.setPakMk(staProtocol.getSiteId(), false);
			// boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
			// if (!result) {
			// throw new CoolException("更新plc站点信息失败==>码垛位自动补充空板：驱动拆盘机输出托盘！");
			// }
			// log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发成功：工作号9999、目标站214！");
			// }else {
			// log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点状态不符合！");
			// }
			// }catch (Exception e){
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			// }

			// /**
			// * 其他 ===>> 拆盘机处空板扫码，驱动托盘向码垛位，不入库
			// */
			// public synchronized void scanBarcodeEmptyBoard() {
			// try {
			//
			// }catch (Exception e){
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			// }

			/**
			* 其他 ===>> 码垛完成驱动托盘进入下一步（入库前扫码）
			*/
			public synchronized void stackingCompletionDriveTray() {
			try {
			int[] staNos=new int[]{216,220,123};//(3个入库站点，1楼1个退货码垛站，2楼两个入库码垛站)
			for (int staNo : staNos){
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp.getWrkNo()!=9992 \|\| Cools.isEmpty(basDevp.getBarcode())){
			continue;
			}
			Integer zpallet = waitPakinMapper.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", basDevp.getBarcode()).eq("status","N"));
			if (zpallet<=0){
			continue;
			}
			// 获取入库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// 入出库模式判断
			// if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
			// if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
			// continue;
			// }

			if (!staProtocol.isLoading()){
			log.info("{}站点无物，正在自动调出空板！",staNo);
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk()
			&& staProtocol.getWorkNo() == 9992
			) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

			staProtocol.setWorkNo(9999);
			staProtocol.setStaNo(staNo + 1);
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
			}

			}
			}
			}catch (Exception e){
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("其他 ===>> 码垛完成驱动托盘进入下一步（入库前扫码）"+e);
			}
			}
			/**
			* 其他 ===>> 码垛完成驱动托盘进入下一步
			*/
			public synchronized void stackingCompletionDriveTray2() {
			try {
			int[] staNos=new int[]{133,135};//(2个入库站点，1楼2个出库码垛站,根据现场修改)
			for (int staNo : staNos){
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp.getWrkNo()<9990){
			continue;
			}
			WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne202(staNo);
			if (Cools.isEmpty(wrkMast)){
			continue;
			}
			// 获取站点信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// 入出库模式判断
			// if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
			// if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
			// continue;
			// }

			if (!staProtocol.isLoading()){
			log.info("{}站点无物，异常！",staNo);
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			&& staProtocol.getWorkNo() >= 9990
			) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
			}
			wrkMast.setWrkSts(52L);
			wrkMastMapper.updateById(wrkMast);

			}
			}
			}catch (Exception e){
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("其他 ===>> 码垛完成驱动托盘进入下一步"+e);
			}
			}
			/**
			* 其他 ===>> 贴标完成驱动托盘进入下一步
			*/
			public synchronized void stackingCompletionDriveTray3() {
			try {
			int[] staNos=new int[]{144};//(1楼1个贴标位,根据现场修改)
			for (int staNo : staNos){
			BasDevp basDevp = basDevpService.selectById(staNo);
			if (basDevp.getWrkNo()<9990){
			continue;
			}
			WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne202(staNo);
			if (Cools.isEmpty(wrkMast)){
			continue;
			}
			// 获取站点信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}

			// 入出库模式判断
			// if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
			// if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
			// continue;
			// }

			if (!staProtocol.isLoading()){
			log.info("{}站点无物，异常！",staNo);
			continue;
			}
			if (!staProtocol.getWorkNo().equals(wrkMast.getWrkNo().shortValue())){
			log.info("站点工作号={} 与贴标工作号={} 不一致，异常！",staProtocol.getWorkNo(),wrkMast.getWrkNo().shortValue());
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing()
			&& staProtocol.isLoading()
			) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

			staProtocol.setWorkNo(wrkMast.getWrkNo());
			staProtocol.setStaNo(wrkMast.getStaNo());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
			if (!result) {
			throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
			}
			wrkMast.setWrkSts(55L);
			wrkMastMapper.updateById(wrkMast);

			}
			}
			}catch (Exception e){
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("其他 ===>> 贴标完成驱动托盘进入下一步"+e);
			}
			}

			/**
			* 完成小车任务
			*/
			public synchronized void rgvCompleteWrkMastSta() {
			try{
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
			continue;
			}

			// 只有当RGV等待WCS确认、自动
			if (rgvProtocol.getStatusType() == RgvStatusType.WAITING
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			) {
			log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
			if (rgvProtocol.getTaskNo1()!=0){
			if (rgvProtocol.getTaskNo1()==9999){
			boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
			if (!rgvComplete){
			log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
			}
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
			rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
			break;
			}
			WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
			if (Cools.isEmpty(wrkMastSta) \|\| wrkMastSta.getType()!=1 \|\| wrkMastSta.getWrkSts()!=1){
			log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
			continue;
			}
			boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
			if (!rgvComplete){
			log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
			break;
			}
			wrkMastSta.setWrkSts(3);
			wrkMastStaMapper.updateById(wrkMastSta);
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
			rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
			}else if (rgvProtocol.getTaskNo2()!=0){
			if (rgvProtocol.getTaskNo2()==9999){
			boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
			if (!rgvComplete){
			log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
			}
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
			rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
			break;
			}
			WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo2().intValue());
			if (Cools.isEmpty(wrkMastSta) \|\| wrkMastSta.getType()!=2){
			log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
			continue;
			}
			boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
			if (!rgvComplete){
			log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
			break;
			}
			wrkMastSta.setWrkSts(3);
			wrkMastStaMapper.updateById(wrkMastSta);
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
			rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
			}else {
			log.error("小车复位失败，小车号{},等待wcs确认但是没有工作号！",rgvProtocol.getRgvNo());
			}
			}
			}
			}catch (Exception e){
			log.error("小车复位线程报错！"+e);
			}
			}
			/**
			* 执行小车搬运任务
			*/
			public synchronized void rgvRunWrkMastFullSta() {
			try{
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
			continue;
			}

			// 只有当RGV空闲、自动,工位一无物//rgv可用
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getLoaded1()==0
			) {
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			if (basRgvMap == null) {
			log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
			continue;
			}
			List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
			List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
			for (WrkMastSta wrkMastSta : wrkMastStaList){
			if (wrkMastSta.getType()!=1 \|\| wrkMastSta.getWrkType()!=3){//1:满版 3：取放
			continue;
			}
			boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta);
			if (sign){
			boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd());
			if (signMap){
			wrkMastSta.setWrkSts(1);
			try{
			wrkMastStaMapper.updateById(wrkMastSta);
			}catch (Exception e){
			log.error("更新小车任务失败");
			}
			return;
			}else {
			log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
			}
			}else {
			log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
			}
			break;
			}
			}
			}
			}catch (Exception e){
			log.error("3875行执行小车搬运任务下发失败");
			log.error("3875行"+e);
			}
			}
			/**
			* 执行小车搬运任务
			*/
			public synchronized void rgvRunWrkMastEmptyStaPut() {//放
			try{
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
			continue;
			}

			// 只有当RGV空闲、自动,工位二有物//rgv可用
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getLoaded2()==1 //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
			) {
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			if (basRgvMap == null) {
			log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
			continue;
			}
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
			List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
			List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);//查询可执行任务
			for (WrkMastSta wrkMastSta : wrkMastStaList){
			if (wrkMastSta.getType()!=2 \|\| (wrkMastSta.getWrkType()!=2 && wrkMastSta.getWrkType()!=4)){// 2:空板 2:放 4：拆盘
			continue;
			}
			boolean sign = false;
			if (wrkMastSta.getStaStart()==0 && wrkMastSta.getStaEnd()!=0){//放
			sign = rgvPutEmpty(rgvProtocol.getRgvNo(),wrkMastSta);
			}else {
			continue;
			}
			if (sign){
			boolean signMap = rgvMapUpdate(basRgvMap, basRgvMap.getStartRoute(), wrkMastSta.getStaEnd());
			if (signMap){
			wrkMastSta.setWrkSts(2);
			try{
			wrkMastStaMapper.updateById(wrkMastSta);
			}catch (Exception e){
			log.error("更新小车任务失败");
			}
			return;
			}else {
			log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
			}
			}else {
			log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
			}
			break;
			}
			}
			}
			}catch (Exception e){
			log.error("3933行执行小车放空板任务下发失败");
			log.error("3933行"+e);
			}
			}

			public synchronized void rgvRunWrkMastEmptyStaTake() {//取
			try{
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
			continue;
			}

			// 只有当RGV空闲、自动,工位二无物//rgv可用
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getLoaded2()==0 //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
			) {
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			if (basRgvMap == null) {
			log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
			continue;
			}
			List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
			List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
			for (WrkMastSta wrkMastSta : wrkMastStaList){
			if (wrkMastSta.getType()!=2 \|\| wrkMastSta.getWrkType()!=1){// 2:空板 1:取
			continue;
			}
			boolean sign = false;
			if (wrkMastSta.getStaEnd()==0 && wrkMastSta.getStaStart()!=0){//取
			sign = rgvTakeEmpty(rgvProtocol.getRgvNo(),wrkMastSta);
			}else {
			continue;
			}
			if (sign){
			boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), basRgvMap.getStartRoute());
			if (signMap){
			wrkMastSta.setWrkSts(1);
			try{
			wrkMastStaMapper.updateById(wrkMastSta);
			}catch (Exception e){
			log.error("更新小车任务失败");
			}
			return;
			}else {
			log.error("3879行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
			}
			}else {
			log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
			}
			break;
			}
			}
			}
			}catch (Exception e){
			log.error("3989行执行小车取空板任务下发失败");
			log.error("3989行"+e);
			}
			}

			/*
			* 有任务但未执行此时需要调整小车位置
			* */
			public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
			try{
			Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
			if (integer==0){
			return;
			}
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
			continue;
			}

			// 只有当RGV空闲、自动,工位一无物//rgv可用
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getLoaded1()==0 //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
			&& rgvProtocol.getTaskNo1()==0
			&& rgvProtocol.getTaskNo2()==0
			) {
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
			continue;
			}
			rgvAvoidanceXY(rgvProtocol.getRgvNo());
			rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
			}
			}
			}catch (Exception e){
			log.error("4109行执行小车初始化任务下发失败");
			log.error("4109行"+e);
			}
			}

			/*
			* 刷新地图数据
			* */
			public synchronized void refreshRgvMap() {
			try{
			for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
			RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
			RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
			if (rgvProtocol == null) {
			continue;
			}
			BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
			if (basRgv == null) {
			log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
			continue;
			}

			// 只有当RGV空闲、自动,工位一无物//rgv可用
			if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
			&& rgvProtocol.getModeType() == RgvModeType.AUTO
			&& rgvProtocol.getLoaded1()==0 //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
			&& (rgvProtocol.getTaskNo1()==0 \|\| rgvProtocol.getTaskNo1()==9999)
			&& (rgvProtocol.getTaskNo2()==0 \|\| rgvProtocol.getTaskNo2()==9999)
			) {
			BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
			basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
			rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
			}
			}
			}catch (Exception e){
			log.error("4109行执行小车初始化任务下发失败");
			log.error("4109行"+e);
			}
			}

			/*
			* 小车XY移动避让
			* */
			public synchronized boolean rgvAvoidanceXY(Integer rgvId){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvId); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1((short)9999); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.GO_ORIGIN); // 工位1任务模式: 回原点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(9, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务 step=9，回原点 9999任务号
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
			return false;
			} else {
			return true;
			}
			}catch (Exception e){
			return false;

			}
			}


			/*
			* 小车取货至工位任务
			* */
			public synchronized boolean rgvTakeFullAll(Integer rgvId,WrkMastSta wrkMastSta){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvId); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式: 取放货
			rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue()); //工位1起点
			rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
			return false;
			} else {
			return true;
			}
			}catch (Exception e){
			return false;
			}
			}

			/*
			* 小车取货至工位任务
			* */
			public synchronized boolean rgvTakeFull(Integer rgvId,WrkMastSta wrkMastSta){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvId); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式: 取货
			rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue()); //工位1起点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
			return false;
			} else {
			return true;
			}
			}catch (Exception e){
			return false;
			}
			}

			/*
			* 小车放货至输送线任务
			* */
			public synchronized boolean rgvPutFull(Integer rgvId,WrkMastSta wrkMastSta){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvId); // RGV编号
			rgvCommand.setAckFinish1((short) 0); // 工位1任务完成确认位
			rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
			rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式: 放货
			rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue()); //工位1目标站点
			rgvCommand.setCommand((short) 1); //工位1任务确认
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(4, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
			return false;
			} else {
			return true;
			}
			}catch (Exception e){
			return false;
			}
			}

			/*
			* 小车取空板至工位任务
			* */
			public synchronized boolean rgvTakeEmpty(Integer rgvId,WrkMastSta wrkMastSta){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvId); // RGV编号
			rgvCommand.setAckFinish2((short) 0); // 工位2任务完成确认位
			rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
			rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式: 取货
			rgvCommand.setSourceStaNo2(wrkMastSta.getStaStart().shortValue()); //工位2起点
			rgvCommand.setCommand((short) 2); //工位2任务确认
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(5, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
			return false;
			} else {
			return true;
			}
			}catch (Exception e){
			return false;
			}
			}

			/*
			* 小车放空板至输送线任务
			* */
			public synchronized boolean rgvPutEmpty(Integer rgvId,WrkMastSta wrkMastSta){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			RgvCommand rgvCommand = new RgvCommand();
			rgvCommand.setRgvNo(rgvId); // RGV编号
			rgvCommand.setAckFinish2((short) 0); // 工位2任务完成确认位
			rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
			rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式: 放货
			rgvCommand.setDestinationStaNo2(wrkMastSta.getStaEnd().shortValue()); //工位2目标站点
			rgvCommand.setCommand((short) 2); //工位2任务确认
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(5, rgvCommand))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
			return false;
			} else {
			return true;
			}
			}catch (Exception e){
			return false;
			}
			}

			/*
			* 小车复位
			* */
			public synchronized boolean rgvComplete(Integer rgvId){
			try{
			// 命令下发区 --------------------------------------------------------------------------
			if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(3, new RgvCommand()))) {
			//step=2,工位1、2写任务； step=4，工位1写任务； step=5，工位2写任务
			log.error("RGV命令下发失败，RGV号={}",rgvId);
			return false;
			} else {
			log.info("RGV命令下发成功，RGV号={}",rgvId);
			return true;
			}
			}catch (Exception e){
			log.error("RGV命令下发失败，RGV号={}。异常："+e,rgvId);
			return false;
			}
			}

			/*
			* 小车地图更新更新锁
			* */
			public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd){

			// List<Integer> integers = RouteUtils.RouteMapCurrentFar(basRgvMapCurrent.getNowRoute(),staStart,staEnd, basRgvMapCurrent.getLockStartRoute());
			//更新当前小车锁
			try{
			Integer farCurrentStaNo = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getNowRoute(), staStart, staEnd, basRgvMapCurrent.getLockStartRoute());//获取最远站点
			Integer fallMerge = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getRgvNo(), farCurrentStaNo); //获取合并干涉项
			basRgvMapCurrent.setLockEndRoute(fallMerge);
			basRgvMapMapper.updateById(basRgvMapCurrent);

			//更新另一台小车地图
			Integer rgvNoOther = basRgvMapCurrent.getRgvNoOther();
			BasRgvMap basRgvMapOther = basRgvMapMapper.selectById(rgvNoOther);
			List<Integer> integers = RouteUtils.RouteMapCurrentFar(fallMerge, basRgvMapCurrent.getLockStartRoute());
			Integer lockEndRoute = RouteUtils.RouteMapOtherFarStnNo(integers, basRgvMapCurrent.getLockStartRoute());//另一台小车可活动最远位置
			basRgvMapOther.setStartRoute(lockEndRoute);
			basRgvMapMapper.updateById(basRgvMapOther);
			return true;
			}catch (Exception e){
			log.error("小车地图更新出错！");
			return false;
			}
			}

			}