zy-wcs.git - Gitblit

			@@ -43,10 +43,7 @@
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;

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

			/**
			@@ -869,6 +866,11 @@
			if (steNo != null) {
			// 小车行走到堆垛机待搬移点
			if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
			// 标记移库当前流程
			wrkMast.setMk("I");
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
			}
			this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
			}
			// 堆垛机将货放至小车上 6.小车待入 ===>> 7.吊车入库中
			@@ -1000,7 +1002,7 @@
			if (wrkMastMapper.updateById(wrkMast) == 0) {
			log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
			// wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
			}
			} else {

			@@ -1362,11 +1364,11 @@
			continue;
			} else {
			// 小车搬至指定库位完成
			if (wrkCharge.getWrkSts() == 4) {
			// 4.迁入小车 ===>> 6.小车待入
			wrkCharge.setWrkSts(6L);
			if (wrkCharge.getWrkSts() == 23) {
			// 23.吊车搬运 ===>> 24.小车到达
			wrkCharge.setWrkSts(24L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 4.迁入小车 ===>> 6.小车待入失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			@@ -1543,6 +1545,37 @@
			} else {
			log.error("修改工作档状态 16.吊车出库中失败！！，工作号={}", wrkMast.getWrkNo());
			}
			} else if (wrkMast.getWrkSts() == 4) {
			// 4.迁入小车 ==> 6.小车待入
			wrkMast.setWrkSts(6L);
			Date now = new Date();
			wrkMast.setCrnEndTime(now);
			wrkMast.setModiTime(now);
			// 修改成功后复位堆垛机
			if (wrkMastMapper.updateById(wrkMast) > 0) {
			// 堆垛机复位
			crnThread.setResetFlag(true);
			// 穿梭车重新定位排列层
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
			if (!steThread.confirmPos()) {
			log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
			}
			// 穿梭车去待机位
			BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
			steCommand.setTaskNo(9999); // 工作号
			steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式: 去近点等待堆垛机叉取
			// steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
			// steCommand.setBay(steProtocol.getBay());
			// steCommand.setLev(steProtocol.getLev());
			if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
			}
			} else {
			log.error("修改工作档状态 4.迁入小车 => 6.小车待入失败！！，工作号={}", wrkMast.getWrkNo());
			}
			// 入库 ===>> 迁出小车完成
			} else if (wrkMast.getWrkSts() == 7){
			// 判断是否需要小车入库
			if (locMastService.isOutMost(wrkMast.getLocNo())) {
			@@ -1627,7 +1660,7 @@
			/**
			* 执行对工作档的完成操作
			*/
			public void carGenerateStore() {
			public synchronized void carGenerateStore() {
			Date now = new Date();
			for (SteSlave ste : slaveProperties.getSte()) {
			// 获取穿梭车信息
			@@ -1646,19 +1679,19 @@
			if (wrkCharge == null) {
			continue;
			} else {
			if (wrkCharge.getWrkSts() == 11) {
			// 11.生成出库ID ===>> 12.小车待搬
			wrkCharge.setWrkSts(12L);
			if (wrkCharge.getWrkSts() == 21) {
			// 21.准备充电 ===>> 22.小车待搬
			wrkCharge.setWrkSts(22L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 11.生成出库ID ===>> 12.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			} else if (wrkCharge.getWrkSts() == 8) {
			// 8.小车搬入库 ===>> 9.入库完成
			wrkCharge.setWrkSts(9L);
			} else if (wrkCharge.getWrkSts() == 25) {
			// 25.小车去充电 ===>> 26.等待充电
			wrkCharge.setWrkSts(26L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 8.小车搬入库 ===>> 9.入库完成失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			@@ -2050,14 +2083,22 @@
			/**
			* 小车电量检测 ===>> 发起充电
			*/
			public void loopSteCharge() {
			public synchronized void loopSteCharge() {
			for (SteSlave ste : slaveProperties.getSte()) {
			SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
			SteProtocol steProtocol = steThread.getSteProtocol();
			BasSte basSte = basSteService.selectById(ste.getId());
			if (Cools.isEmpty(steProtocol, basSte)) { continue; }
			try {
			if (!steProtocol.statusType.equals(SteStatusType.IDLE) \|\| basSte.getPakMk().equals("Y")) {
			// 在线空闲无作业标记不在充电
			if (steProtocol.getMode() == 0
			\|\| !steProtocol.statusType.equals(SteStatusType.IDLE)
			\|\| basSte.getPakMk().equals("Y")
			// \|\| steProtocol.getChargeStatus() == 1
			) {
			continue;
			}
			if (!steProtocol.isEnable()) {
			continue;
			}
			if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
			@@ -2065,12 +2106,12 @@
			}
			WrkCharge wrkCharge = wrkChargeService.selectWorking(steProtocol.getSteNo().intValue());

			if (wrkCharge == null) {
			if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
			String idleLoc = basSte.getIdleLoc();
			wrkCharge = new WrkCharge();
			wrkCharge.setSteNo(ste.getId());
			wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
			wrkCharge.setWrkSts(11L);
			wrkCharge.setWrkSts(21L); // 21.准备充电
			wrkCharge.setCrnNo(basSte.getCrnNo());
			wrkCharge.setIoPri((double) 10);
			wrkCharge.setLocNo(idleLoc);
			@@ -2079,20 +2120,26 @@
			continue;
			}

			// 处于充电库位组
			if (Utils.getGroupRow(idleLoc).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(idleLoc) && steProtocol.getLev() == Utils.getLev(idleLoc)) {
			// 修改工作档状态 11.生成出库ID => 6.小车待入
			wrkCharge.setWrkSts(6L);
			// 修改工作档状态 21.准备充电 => 24.小车到达
			wrkCharge.setWrkSts(24L);
			wrkCharge.setModiTime(new Date());
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 11.生成出库ID => 6.小车待入失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 21.准备充电 => 24.小车到达失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			} else {
			this.letCarBeWaiting(wrkCharge, ste.getId());
			}

			} else {
			// 12.小车待搬
			if (wrkCharge.getWrkSts() == 12) {
			// filter
			if (wrkCharge == null \|\| (wrkCharge.getWrkSts() < 26 && steProtocol.getChargeStatus() == 1)) {
			continue;
			}

			// 22.小车待搬
			if (wrkCharge.getWrkSts() == 22) {
			// 搬小车至充电库位
			LocMast locMast = locMastService.selectById(basSte.getIdleLoc());

			@@ -2113,19 +2160,20 @@
			} else {
			// 修改穿梭车运行中排列层
			steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
			// 修改工作档状态 12.小车待搬 => 4.迁入小车
			// 修改工作档状态 22.小车待搬 => 23.吊车搬运
			Date now = new Date();
			wrkCharge.setWrkSts(4L);
			wrkCharge.setWrkSts(23L);
			wrkCharge.setCrnStrTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 12.小车待搬 => 4.迁入小车失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}

			} else if (wrkCharge.getWrkSts() == 6L) {
			} else if (wrkCharge.getWrkSts() == 24L) {
			// 小车行驶至充电位
			if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
			if (steProtocol.getChargeStatus() == 1) { continue; }
			// 命令下发区 --------------------------------------------------------------------------
			SteCommand steCommand = new SteCommand();
			steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
			@@ -2134,26 +2182,29 @@
			if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
			log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
			} else {
			// 修改工作档状态 6.小车待入 ===> 8.小车搬入库
			wrkCharge.setWrkSts(8L);
			// 修改工作档状态 24.小车到达 ===> 25.小车去充电
			wrkCharge.setWrkSts(25L);
			Date now = new Date();
			wrkCharge.setCrnEndTime(now);
			wrkCharge.setModiTime(now);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改工作档状态 6.小车待入 ===> 8.小车搬入库失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 24.小车到达 ===> 25.小车去充电失败！！，工作号={}", wrkCharge.getWrkNo());
			}
			}
			}
			} else if (wrkCharge.getWrkSts() == 9L) {
			} else if (wrkCharge.getWrkSts() == 26) {
			if (steProtocol.getChargeStatus() == 0) { continue; }
			// 给输送线下发充电任务
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			SteChargeType steChargeType = SteChargeType.get(wrkCharge.getLocNo());
			if (null != steChargeType) {
			if (devpThread.charge(steChargeType.ssbm - 1, true)) {
			// 修改工作档状态 9.入库完成 ===> 10.库存更新完成
			wrkCharge.setWrkSts(10L);
			// 修改工作档状态 26.等待充电 ===> 28.完成充电
			wrkCharge.setWrkSts(28L);
			if (!wrkChargeService.updateById(wrkCharge)) {
			log.error("修改充电任务状态 9.入库完成 ===> 10.库存更新完成失败！！，工作号={}", wrkCharge.getWrkNo());
			log.error("修改充电任务状态 26.等待充电 ===> 28.完成充电失败！！，工作号={}", wrkCharge.getWrkNo());
			} else {
			steThread.setResetFlag(true);
			}
			}
			} else {
			@@ -2167,4 +2218,173 @@
			}
			}


			public List<String> crn1DemoLocs = new ArrayList<String>(); public String crn1LastLoc = "";
			public List<String> crn2DemoLocs = new ArrayList<String>(); public String crn2LastLoc = "";
			public List<String> crn3DemoLocs = new ArrayList<String>(); public String crn3LastLoc = "";
			public synchronized void demo() {
			if (Cools.isEmpty(crn1DemoLocs)) {
			crn1DemoLocs = locMastService.getDemoNextLoc(1);
			}
			if (Cools.isEmpty(crn2DemoLocs)) {
			crn2DemoLocs = locMastService.getDemoNextLoc(2);
			}
			if (Cools.isEmpty(crn3DemoLocs)) {
			crn3DemoLocs = locMastService.getDemoNextLoc(3);
			}
			for (CrnSlave crn : slaveProperties.getCrn()) {
			if (!crn.getDemo()) {
			continue;
			} // 必须为演示状态

			// CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			// CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			// if (crnProtocol == null) {
			// continue;
			// }

			// 只有当堆垛机空闲并且无任务时才继续执行
			// if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {

			String locNo = null;
			Iterator<String> iterator = crn1DemoLocs.iterator();
			if (crn.getId() == 1) {
			iterator = crn1DemoLocs.iterator();
			} else if (crn.getId() == 2) {
			iterator = crn2DemoLocs.iterator();
			} else if (crn.getId() == 3) {
			iterator = crn3DemoLocs.iterator();
			}
			while (iterator.hasNext()) {
			String next = iterator.next();
			String lastLoc = "";
			if (crn.getId() == 1) {
			lastLoc = crn1LastLoc;
			} else if (crn.getId() == 2) {
			lastLoc = crn2LastLoc;
			} else if (crn.getId() == 3) {
			lastLoc = crn3LastLoc;
			}
			if (!Cools.isEmpty(lastLoc)) {
			if (!lastLoc.substring(2, 7).equals(next.substring(2, 7)) \|\| !Utils.getGroupRow(lastLoc).equals(Utils.getGroupRow(next))) {
			locNo = next;
			iterator.remove();
			break;
			} else {
			iterator.remove();
			}
			} else {
			locNo = next;
			iterator.remove();
			break;
			}

			}
			if (!Cools.isEmpty(locNo)) {
			if (crn.getId() == 1) {
			crn1LastLoc = locNo;
			} else if (crn.getId() == 2) {
			crn2LastLoc = locNo;
			} else if (crn.getId() == 3) {
			crn3LastLoc = locNo;
			}
			}

			log.info("{}号堆垛机对{}库位进行演示", crn.getId(), locNo);

			}

			// }
			}

			/**
			* 堆垛机演示 ===>> 库位移转
			*/
			public synchronized void crnDemoOfLocMove(){
			for (CrnSlave crn : slaveProperties.getCrn()) {
			if (!crn.getDemo()) { continue; } // 必须为演示状态

			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }

			log.info("{}号堆垛机正在演示", crn.getId());

			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
			// // 获取移库工作档信息
			// WrkMast wrkMast = wrkMastMapper.selectLocMove(crn.getId());
			// if (null != wrkMast) { continue; }
			//
			// LocMast sourceLoc = locMastService.queryDemoSourceLoc(crn.getId());
			// LocMast loc = locMastService.queryDemoLoc(crn.getId());
			// if (null == sourceLoc \|\| null == loc) { continue; }
			//
			// String sourceLocNo = sourceLoc.getLocNo();
			// String locNo = loc.getLocNo();
			//
			// // 获取工作号
			// int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
			// // 保存工作档
			// wrkMast = new WrkMast();
			// wrkMast.setWrkNo(workNo);
			// wrkMast.setIoTime(new Date());
			// wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
			// wrkMast.setIoType(11); // 入出库状态： 11.库格移载
			// wrkMast.setIoPri(13D);
			// wrkMast.setCrnNo(crn.getId());
			// wrkMast.setSourceLocNo(sourceLocNo); // 源库位
			// wrkMast.setLocNo(locNo); // 目标库位
			// wrkMast.setFullPlt("N"); // 满板：Y
			// wrkMast.setPicking("N"); // 拣料
			// wrkMast.setExitMk("N"); // 退出
			// wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D")?"Y":"N"); // 空板
			// wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
			// wrkMast.setLinkMis("N");
			// wrkMast.setAppeTime(new Date());
			// wrkMast.setModiTime(new Date());
			// int res = wrkMastMapper.insert(wrkMast);
			// if (res == 0) {
			// throw new CoolException("保存工作档失败");
			// }
			// // 工作档明细保存
			// List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
			// for (LocDetl locDetl : locDetls) {
			// WrkDetl wrkDetl = new WrkDetl();
			// wrkDetl.sync(locDetl);
			// wrkDetl.setWrkNo(workNo);
			// wrkDetl.setIoTime(new Date());
			// wrkDetl.setAnfme(locDetl.getAnfme());
			// wrkDetl.setAppeTime(new Date());
			// wrkDetl.setModiTime(new Date());
			// if (!wrkDetlService.insert(wrkDetl)) {
			// throw new CoolException("保存工作档明细失败");
			// }
			// }
			// // 修改源库位状态
			// if (sourceLoc.getLocSts().equals("D") \|\| sourceLoc.getLocSts().equals("F")) {
			// sourceLoc.setLocSts("R"); // R.出库预约
			// sourceLoc.setModiTime(new Date());
			// if (!locMastService.updateById(sourceLoc)){
			// throw new CoolException("更新源库位状态失败");
			// }
			// } else {
			// throw new CoolException("源库位出库失败");
			// }
			// // 修改目标库位状态
			// if (loc.getLocSts().equals("O")) {
			// loc.setLocSts("S"); // S.入库预约
			// loc.setModiTime(new Date());
			// if (!locMastService.updateById(loc)) {
			// throw new CoolException("更新目标库位状态失败");
			// }
			// } else {
			// throw new CoolException("移转失败");
			// }

			}

			}
			}

			}