zy-wcs.git - Gitblit

			@@ -1643,19 +1643,10 @@
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
			if (steThread.confirmPos()) {
			// 穿梭车下发充电任务
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 27.放至充电位 ===>> 28.开始充电
			wrkCharge.setWrkSts(28L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 27.放至充电位 ===>> 28.开始充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			// 27.放至充电位 ===>> 28.充电就绪
			wrkCharge.setWrkSts(28L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 27.放至充电位 ===>> 28.充电就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
			@@ -1894,11 +1885,11 @@
			} else {
			steThread.setResetFlag(true);
			}
			} else if (wrkCharge.getWrkSts() == 28) {
			// 28.开始充电 ===>> 29.完成充电
			wrkCharge.setWrkSts(29L);
			} else if (wrkCharge.getWrkSts() == 29) {
			// 29.开始充电 ===>> 30.完成充电
			wrkCharge.setWrkSts(30L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 28.开始充电 ===>> 29.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -1906,7 +1897,7 @@
			// 32.小车走行 ===>> 33.小车待搬
			wrkCharge.setWrkSts(33L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改演示任务状态 32.小车走行 ===>> 33.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2458,6 +2449,7 @@
			/**
			* 小车电量检测 ===>> 发起充电
			*/
			@SuppressWarnings("serial")
			public synchronized void loopSteCharge() {
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			for (SteSlave ste : slaveProperties.getSte()) {
			@@ -2470,6 +2462,7 @@
			if (steProtocol.getMode() == 0
			\|\| !steProtocol.statusType.equals(SteStatusType.IDLE)
			\|\| basSte.getPakMk().equals("Y")
			\|\| basSte.getAutoCharge().equals("N")
			// \|\| steProtocol.getChargeStatus() == 1
			) {
			continue;
			@@ -2484,7 +2477,33 @@

			if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
			// 寻找空闲充电桩
			SteChargeType steCharge = devpThread.getIdleChargeLocNo();
			SteChargeType steCharge = null;
			do {
			String locNo;
			if (!devpThread.charge0) {
			locNo = SteChargeType.FIRST.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null) {
			steCharge = SteChargeType.FIRST;
			break;
			}
			}
			if (!devpThread.charge1) {
			locNo = SteChargeType.SECOND.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null) {
			steCharge = SteChargeType.SECOND;
			break;
			}
			}
			if (!devpThread.charge2) {
			locNo = SteChargeType.THIRD.locNo;
			if (basSteService.hasCarOfLocNo(locNo) == null) {
			steCharge = SteChargeType.THIRD;
			break;
			}
			}
			break;
			} while (false);

			if (steCharge == null) {
			log.warn("{}号小车【电量：{}】充电失败，原因：没有空闲充电桩。", ste.getId(), steProtocol.getCharge());
			continue;
			@@ -2507,11 +2526,11 @@
			if (steProtocol.getRow().intValue() == Utils.getRow(chargeLocNo)
			&& steProtocol.getBay().intValue() == Utils.getBay(chargeLocNo)
			&& steProtocol.getLev().intValue() == Utils.getLev(chargeLocNo)) {
			// 修改工作档状态 21.准备充电 => 24.小车到达
			wrkCharge.setWrkSts(24L);
			// 修改工作档状态 21.准备充电 => 28.充电就绪
			wrkCharge.setWrkSts(28L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 21.准备充电 => 28.充电就绪失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			this.letCarBeWaiting(wrkCharge, ste.getId());
			@@ -2519,7 +2538,7 @@

			} else {
			// filter
			if (wrkCharge == null \|\| (wrkCharge.getWrkSts() < 26 && steProtocol.getChargeStatus() == 1)) {
			if (wrkCharge == null \|\| (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1)) {
			continue;
			}

			@@ -2636,6 +2655,21 @@
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 28L) {
			// 穿梭车下发充电任务
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
			steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 28.充电就绪 ===>> 29.开始充电
			wrkCharge.setWrkSts(29L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			}
			} catch (Exception e) {
			@@ -2644,6 +2678,117 @@
			}
			}

			/**
			* 小车从充电桩至待机库位
			*/
			public synchronized void steFromChargeToIdleLoc() {
			// 与充电任务不同步进行
			if (null != wrkChargeService.selectWorking(null)) { return; }
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			// 检索充电桩
			for (SteChargeType value : SteChargeType.values()) {
			Integer steNo = basSteService.hasCarOfLocNo(value.locNo);
			if (steNo != null) {
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(steNo);
			if (Cools.isEmpty(steProtocol, basSte)) {
			continue;
			}
			// 1号充电桩
			if (value.equals(SteChargeType.FIRST) && devpThread.charge0) {
			continue;
			}
			// 2号充电桩
			if (value.equals(SteChargeType.SECOND) && devpThread.charge1) {
			continue;
			}
			// 3号充电桩
			if (value.equals(SteChargeType.THIRD) && devpThread.charge2) {
			continue;
			}
			// 小车是否处于充电状态
			if (steProtocol.getChargeStatus() == 1) {
			continue;
			}
			// case 1 : 自动充电开馈电 ×
			// case 2 : 自动充电开满电 ✔
			// case 3 : 自动充电关馈电 ✔
			// case 4 : 自动充电关满电 ✔
			if (basSte.getAutoCharge().equals("Y")
			&& steProtocol.getCharge() < Float.parseFloat(basSte.getChargeLine())) {
			continue;
			}
			// 开始穿梭车复位任务
			WrkCharge wrkCharge = new WrkCharge();
			wrkCharge.setSteNo(steNo);
			wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
			wrkCharge.setWrkSts(41L); // 41.小车准备复位
			wrkCharge.setCrnNo(2); // 固定2号堆垛机
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setSourceLocNo(value.locNo);
			wrkCharge.setLocNo(basSte.getIdleLoc());
			wrkCharge.setMemo("reset");
			if (!wrkChargeService.insert(wrkCharge)) {
			log.error("保存{}号穿梭车复位任务失败!!!", steNo);
			continue;
			}

			// 1.搬运至固定通道
			if (wrkCharge.getWrkSts() == 41L) {
			// 搬小车至小车走向通道
			List<String> channel = slaveProperties.getChannel();
			for (String channelLocNo : channel) {
			Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
			if (null != otherSte) {
			log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
			} else {
			// 固定堆垛机
			int crnNo = 1;
			LocMast channelLoc = locMastService.selectById(channelLocNo);

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// 堆垛机命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(crnNo); // 堆垛机编号
			crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue()); // 源库位排
			crnCommand.setSourcePosY(steProtocol.getBay()); // 源库位列
			crnCommand.setSourcePosZ(steProtocol.getLev()); // 源库位层
			crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), false).shortValue()); // 目标库位排
			crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue()); // 目标库位列
			crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue()); // 目标库位层
			if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
			// 修改工作档状态 41.小车准备复位 => 42.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(42L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 41.小车准备复位 => 42.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			break;
			}

			}
			}

			}
			}
			}
			}


			/**
			* 因双深库位阻塞，对浅库位进行移转（出库版)