zy-wcs.git - Gitblit

			@@ -1,9 +1,12 @@
			package com.zy.asrs.service.impl;

			import com.alibaba.fastjson.JSON;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			import com.zy.asrs.domain.enums.NotifyMsgType;
			import com.zy.asrs.entity.*;
			import com.zy.asrs.mapper.*;
			import com.zy.asrs.service.*;
			import com.zy.asrs.utils.NotifyUtils;
			import com.zy.asrs.utils.Utils;
			import com.zy.common.model.*;
			import com.zy.common.model.enums.NavigationMapType;
			@@ -43,9 +46,9 @@
			@Autowired
			private WrkMastService wrkMastService;
			@Autowired
			private LocMastService locMastService;
			private WrkMastLogMapper wrkMastLogMapper;
			@Autowired
			private StaDescService staDescService;
			private LocMastService locMastService;
			@Autowired
			private BasDevpService basDevpService;
			@Autowired
			@@ -54,6 +57,8 @@
			private BasLiftErrLogService basLiftErrLogService;
			@Autowired
			private BasShuttleErrService basShuttleErrService;
			@Autowired
			private BasLiftErrService basLiftErrService;
			@Autowired
			private CommonService commonService;
			@Autowired
			@@ -64,8 +69,6 @@
			private ShuttleDispatchUtils shuttleDispatchUtils;
			@Autowired
			private RedisUtil redisUtil;
			@Autowired
			private WrkMastLogMapper wrkMastLogMapper;
			@Autowired
			private BasLiftOptService basLiftOptService;
			@Autowired
			@@ -82,6 +85,8 @@
			private ShuttleAction shuttleAction;
			@Autowired
			private ForkLiftAction forkLiftAction;
			@Autowired
			private NotifyUtils notifyUtils;


			// /**
			@@ -523,7 +528,7 @@
			*/
			public synchronized void initRealtimeBasMap() {
			try {
			for (int i = 1; i <= 10; i++) {//总共四层楼
			for (int i = 1; i <= 4; i++) {//总共四层楼
			Object data = redisUtil.get(RedisKeyType.MAP.key + i);
			if (data == null) {//redis地图数据为空，从数据库中获取
			BasMap basMap = basMapService.selectLatestMap(i);
			@@ -819,116 +824,202 @@
			// return true;
			// }

			// /**
			// * 四向穿梭车任务完成
			// */
			// public synchronized void shuttleFinished() {
			// try {
			// for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			// //获取四向穿梭车信息
			// NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
			// NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
			// if (shuttleProtocol == null) {
			// continue;
			// }
			//
			// //四向穿梭车状态为等待确认、小车处于空闲状态
			// if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id //任务完成等待确认
			// && shuttleProtocol.getTaskNo() != 0
			// && shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
			// ) {
			// //将任务档标记为完成
			// WrkMast wrkMast = wrkMastMapper.selectByWorkNo(shuttleProtocol.getTaskNo());
			// if (wrkMast != null) {
			/**
			* 四向穿梭车任务完成
			*/
			public synchronized void shuttleFinished() {
			try {
			for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			//获取四向穿梭车信息
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			continue;
			}

			//四向穿梭车状态为等待确认、小车处于空闲状态
			if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id //任务完成等待确认
			&& shuttleProtocol.getTaskNo() != 0
			) {
			//将任务档标记为完成
			WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
			if (wrkMast != null) {
			if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE.sts) {
			//302.小车移动至站点 ==> 303.小车移动至站点完成
			wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
			shuttleThread.setSyncTaskNo(0);
			} else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_LIFT.sts) {
			//308.小车迁出提升机中 ==> 309.小车迁出提升机完成
			wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
			shuttleThread.setSyncTaskNo(0);
			} else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SHUTTLE.sts) {
			//310.小车移动中 ==> 311.小车移动完成
			wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
			shuttleThread.setSyncTaskNo(0);
			notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_MOVE_COMPLETE);//触发通知
			} else if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
			//204.小车充电中 ==> 205.小车充电完成
			wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
			shuttleThread.setSyncTaskNo(0);
			notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//触发通知
			} else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_SHUTTLE_RUN.sts) {
			//502.小车搬运中 ==> 509.移库完成
			wrkMast.setWrkSts(WrkStsType.COMPLETE_LOC_MOVE.sts);
			shuttleThread.setSyncTaskNo(0);
			notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_DELIVERY);//触发通知
			} else {
			continue;
			}
			// switch (wrkMast.getWrkSts().intValue()) {
			// case 5://5.小车搬运中 ==> 9.入库完成
			// wrkMast.setWrkSts(9L);
			// shuttleProtocol.setTaskNo(0);
			// if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
			// //释放小车令牌
			// shuttleProtocol.setToken(0);
			// }
			//// case 5://5.小车搬运中 ==> 9.入库完成
			//// wrkMast.setWrkSts(9L);
			//// shuttleProtocol.setTaskNo(0);
			//// if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
			//// //释放小车令牌
			//// shuttleProtocol.setToken(0);
			//// }
			//// break;
			//// case 22://22.小车搬运中 ==> 23.小车搬运完成
			//// wrkMast.setWrkSts(23L);
			//// shuttleProtocol.setTaskNo(0);
			//// if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
			//// //释放小车令牌
			//// shuttleProtocol.setToken(0);
			//// }
			//// break;
			// case 302:
			// wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
			// break;
			// case 22://22.小车搬运中 ==> 23.小车搬运完成
			// wrkMast.setWrkSts(23L);
			// shuttleProtocol.setTaskNo(0);
			// if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
			// //释放小车令牌
			// shuttleProtocol.setToken(0);
			// }
			// break;
			// case 102://102.小车移动至站点 ==> 103.小车移动至站点完成
			// wrkMast.setWrkSts(103L);
			// break;
			// case 104://104.小车迁入提升机中 ==> 105.小车迁入提升机完成
			// wrkMast.setWrkSts(105L);
			// shuttleProtocol.setTaskNo(0);//清理工作号
			// break;
			// case 108://108.小车迁出提升机中 ==> 109.小车迁出提升机完成
			// wrkMast.setWrkSts(109L);
			// break;
			// case 110://110.小车移动中 ==> 111.小车移动完成
			// wrkMast.setWrkSts(111L);
			// shuttleProtocol.setTaskNo(0);
			// if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
			// //释放小车令牌
			// shuttleProtocol.setToken(0);
			// }
			// case WrkStsType.MOVE_SHUTTLE.sts:
			// wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
			// shuttleThread.setSyncTaskNo(0);
			// break;
			// default:
			// }
			//
			// if (wrkMastMapper.updateById(wrkMast) > 0) {
			// if (wrkMast.getWrkSts() == 111) {
			// // 保存工作主档历史档
			// if (wrkMastLogMapper.save(wrkMast.getWrkNo()) <= 0) {
			// log.info("保存工作历史档[workNo={0}]失败", wrkMast.getWrkNo());
			// }
			// // 删除工作主档
			// if (!wrkMastService.deleteById(wrkMast)) {
			// log.info("删除工作主档[workNo={0}]失败", wrkMast.getWrkNo());
			// }
			// }
			//
			// //设置四向穿梭车为空闲状态
			// shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
			// //源库位清零
			// shuttleProtocol.setSourceLocNo(null);
			// //目标库位清零
			// shuttleProtocol.setLocNo(null);
			// //任务指令清零
			// shuttleProtocol.setAssignCommand(null);
			// News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
			// } else {
			// News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
			// }
			// } else {
			// ShuttleAssignCommand assignCommand = shuttleProtocol.getAssignCommand();
			// if (!assignCommand.getAuto()) {
			// //手动模式
			// //工作号清零
			// shuttleProtocol.setTaskNo(0);
			// //设置四向穿梭车为空闲状态
			// shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
			// //源库位清零
			// shuttleProtocol.setSourceLocNo(null);
			// //目标库位清零
			// shuttleProtocol.setLocNo(null);
			// //任务指令清零
			// shuttleProtocol.setAssignCommand(null);
			// //清零令牌
			// shuttleProtocol.setToken(0);
			// News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
			// }
			// }
			//
			// }
			//
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			// }

			if (wrkMastService.updateById(wrkMast)) {
			//设置四向穿梭车为空闲状态
			shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
			News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
			} else {
			News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
			}
			} else {
			Object object = redisUtil.get(RedisKeyType.SHUTTLE_WORK_FLAG.key + shuttleProtocol.getTaskNo());
			if(object != null){
			ShuttleAssignCommand assignCommand = JSON.parseObject(object.toString(), ShuttleAssignCommand.class);
			if (!assignCommand.getAuto()) {
			//手动模式
			//工作号清零
			shuttleThread.setTaskNo(0);
			//设置四向穿梭车为空闲状态
			shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
			News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
			}
			}
			}
			}

			}
			} catch (Exception e) {
			e.printStackTrace();
			}
			}

			/**
			* 执行移库任务
			*/
			public synchronized void shuttleLocMoveExecute() {
			try {
			//查询移库任务
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_LOC_MOVE.sts));
			for (WrkMast wrkMast : wrkMasts) {
			boolean stepToTarget = this.shuttleLocMoveExecuteToTarget(wrkMast);//移库任务-小车去目标点
			if (!stepToTarget) {
			continue;
			}

			}
			} catch (Exception e) {
			e.printStackTrace();
			}
			}

			/**
			* 移库任务-小车去目标点
			* 如需主方法执行continue，请返回false
			* ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
			*/
			private boolean shuttleLocMoveExecuteToTarget(WrkMast wrkMast) {
			//--------------------------------------小车移动至站点-----------------------------------------//
			Date now = new Date();

			//小车移动至站点 501.生成移库任务 ==> 502.小车搬运中
			if (wrkMast.getWrkSts() == WrkStsType.NEW_LOC_MOVE.sts) {
			if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
			boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物点进行取货
			News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
			return false;
			}

			//获取四向穿梭车线程
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车未到达取货位置", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
			return false;
			}

			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
			assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
			assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
			assignCommand.setAuto(true);//自动模式

			//获取小车到输送站点行走命令
			List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
			if (commands == null) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;
			}

			List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
			if (liftCommand == null) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;
			}

			List<ShuttleCommand> liftCommand2 = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
			if (liftCommand2 == null) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取下降命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;
			}

			commands.add(0, liftCommand.get(0));
			commands.add(liftCommand2.get(0));
			assignCommand.setCommands(commands);

			wrkMast.setWrkSts(WrkStsType.LOC_MOVE_SHUTTLE_RUN.sts);//小车搬运中 501.生成移库任务 ==> 502.小车搬运中
			wrkMast.setModiTime(now);
			wrkMast.setSystemMsg("");//清空消息
			if (wrkMastService.updateById(wrkMast)) {
			//下发任务
			shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
			//触发通知
			notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_MOVING);
			return false;
			}
			return false;
			}
			return true;
			}

			// /**
			// * 提升机任务
			@@ -1253,37 +1344,27 @@
			// return true;
			// }
			//
			// /**
			// * 提升机任务完成
			// */
			// public synchronized void liftFinished() {
			// try {
			// for (LiftSlave liftSlave : slaveProperties.getLift()) {
			// //获取提升机信息
			// LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
			// LiftProtocol liftProtocol = liftThread.getLiftProtocol();
			// if (liftProtocol == null) {
			// continue;
			// }
			//
			// //提升机为等待确认且空闲
			// if (liftProtocol.getProtocolStatus() == LiftProtocolStatusType.WAITING.id
			// && liftProtocol.getTaskNo() != 0
			// && !liftProtocol.getBusy()
			// ) {
			// int taskNo = liftProtocol.getTaskNo().intValue();
			// if (taskNo >= 20000 && taskNo <= 30000) {
			// //提升机设备工作号，需要查询对应任务号
			// BasLiftOpt basLiftOpt = basLiftOptService.selectByDeviceWrk(liftProtocol.getTaskNo().toString(), liftSlave.getId());
			// if (basLiftOpt != null) {
			// taskNo = basLiftOpt.getWrkNo();
			// }
			// }
			//
			// //将任务档标记为完成
			// WrkMast wrkMast = wrkMastMapper.selectByWorkNo324104(taskNo);
			// if (wrkMast != null) {
			// switch (wrkMast.getWrkSts().intValue()) {
			/**
			* 货叉提升机任务完成
			*/
			public synchronized void forkLiftFinished() {
			try {
			for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
			//获取提升机信息
			ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
			ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
			if (forkLiftProtocol == null) {
			continue;
			}

			//提升机为等待确认且空闲
			if (forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.WAITING.id
			&& forkLiftProtocol.getWrkNo() != 0
			) {
			//将任务档标记为完成
			WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
			if (wrkMast != null) {
			switch (wrkMast.getWrkSts().intValue()) {
			// case 3://3.提升机搬运中 ==> 4.提升机搬运完成
			// wrkMast.setWrkSts(4L);
			// wrkMast.setLiftNo(null);//释放提升机
			@@ -1305,263 +1386,185 @@
			// wrkMast.setModiTime(new Date());
			// }
			// }
			//
			// if (liftProtocol.getToken().equals(wrkMast.getWrkNo())) {
			// //释放提升机令牌
			// liftProtocol.setToken(0);
			// }
			//
			// break;
			// case 106://106.提升机搬运中 ==> 107.提升机搬运完成
			// wrkMast.setWrkSts(107L);
			// break;
			// default:
			// }
			//
			// if (wrkMastMapper.updateById(wrkMast) > 0) {
			// //设置提升机为空闲状态
			// liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
			// //任务指令清零
			// liftProtocol.setAssignCommand(null);
			// News.info("提升机已确认且任务完成状态。提升机号={}", liftProtocol.getLiftNo());
			// } else {
			// News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
			// }
			// } else {
			// LiftAssignCommand assignCommand = liftProtocol.getAssignCommand();
			// if (assignCommand != null) {
			// if (!assignCommand.getAuto()) {
			// //手动操作
			// //设置提升机为空闲状态
			// liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
			// //任务指令清零
			// liftProtocol.setAssignCommand(null);
			// News.info("提升机已确认手动操作。提升机号={}", liftProtocol.getLiftNo());
			// }
			// }
			// }
			// }
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			// }
			case 306://306.提升机搬运中 ==> 307.提升机搬运完成
			wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
			forkLiftThread.setSyncTaskNo(0);
			break;
			default:
			}

			// /**
			// * 异常信息记录
			// */
			// public void recErr() {
			// try {
			// this.recShuttleErr();
			// this.recLiftErr();
			// } catch (Exception e) {
			// News.error("recErr fail", e);
			// }
			// }
			wrkMast.setModiTime(new Date());
			if (wrkMastService.updateById(wrkMast)) {
			forkLiftThread.reset();
			News.info("提升机已确认且任务完成状态。提升机号={}", forkLiftProtocol.getLiftNo());
			} else {
			News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", forkLiftProtocol.getLiftNo(), forkLiftProtocol.getWrkNo());
			}
			}
			}
			}
			} catch (Exception e) {
			e.printStackTrace();
			}
			}

			// /**
			// * 四向穿梭车异常信息记录
			// */
			// private void recShuttleErr() {
			// Date now = new Date();
			// for (ShuttleSlave shuttleSlave : slaveProperties.getShuttle()) {
			// // 获取四向穿梭车信息
			// NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleSlave.getId());
			// if (shuttleThread == null) {
			// continue;
			// }
			// NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
			// if (shuttleProtocol == null) {
			// continue;
			// }
			//
			// if (shuttleProtocol.getTaskNo() != 0) {
			// //有任务
			// BasShuttleErrLog latest = basShuttleErrLogService.findLatestByTaskNo(shuttleSlave.getId(), shuttleProtocol.getTaskNo());
			// // 有异常
			// if (latest == null) {
			// if (shuttleProtocol.getErrState() != null && shuttleProtocol.getErrState() == 1) {
			// WrkMast wrkMast = wrkMastMapper.selectById(shuttleProtocol.getTaskNo());
			// if (wrkMast == null) {
			// continue;
			// }
			// BasShuttleErr basShuttleErr = basShuttleErrService.queryByCode(shuttleProtocol.getErrCode());
			// String errName = basShuttleErr==null? "未知异常":basShuttleErr.getErrName();
			// BasShuttleErrLog basShuttleErrLog = new BasShuttleErrLog(
			// null, // 编号
			// wrkMast.getWrkNo(), // 工作号
			// now, // 发生时间
			// null, // 结束时间
			// wrkMast.getWrkSts(), // 工作状态
			// wrkMast.getIoType(), // 入出库类型
			// shuttleSlave.getId(), // 四向穿梭车
			// null, // plc
			// wrkMast.getLocNo(), // 目标库位
			// wrkMast.getStaNo(), // 目标站
			// wrkMast.getSourceStaNo(), // 源站
			// wrkMast.getSourceLocNo(), // 源库位
			// wrkMast.getBarcode(), // 条码
			// shuttleProtocol.getErrCode(), // 异常码
			// errName, // 异常
			// 1, // 异常情况
			// now, // 添加时间
			// null, // 添加人员
			// now, // 修改时间
			// null, // 修改人员
			// "任务中异常", // 备注
			// JSON.toJSONString(shuttleProtocol) // 系统状态数据
			// );
			// if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
			// News.error("四向穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
			// }
			// }
			// } else {
			// // 异常修复
			// if (shuttleProtocol.getErrState() == null \|\| shuttleProtocol.getErrState() == 0) {
			// latest.setEndTime(now);
			// latest.setUpdateTime(now);
			// latest.setStatus(2);
			// if (!basShuttleErrLogService.updateById(latest)) {
			// News.error("四向穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
			// }
			// }
			// }
			// }else {
			//// //无任务
			//// BasShuttleErrLog latest = basShuttleErrLogService.findLatest(shuttleSlave.getId());
			//// // 有异常
			//// if (shuttleProtocol.getStatusErrorCode() != null && shuttleProtocol.getStatusErrorCode() > 0) {
			//// // 记录新异常
			//// if (latest == null \|\| (latest.getErrCode() != shuttleProtocol.getStatusErrorCode().intValue())) {
			//// BasShuttleErr basShuttleErr = basShuttleErrService.queryByCode(shuttleProtocol.getStatusErrorCode().intValue());
			//// String errName = basShuttleErr==null? "未知异常":basShuttleErr.getErrName();
			//// BasShuttleErrLog basShuttleErrLog = new BasShuttleErrLog(
			//// null, // 编号
			//// null, // 工作号
			//// now, // 发生时间
			//// null, // 结束时间
			//// null, // 工作状态
			//// null, // 入出库类型
			//// shuttleSlave.getId(), // 四向穿梭车
			//// null, // plc
			//// null, // 目标库位
			//// null, // 目标站
			//// null, // 源站
			//// null, // 源库位
			//// null, // 条码
			//// (int)shuttleProtocol.getStatusErrorCode(), // 异常码
			//// errName, // 异常
			//// 1, // 异常情况
			//// now, // 添加时间
			//// null, // 添加人员
			//// now, // 修改时间
			//// null, // 修改人员
			//// "无任务异常" // 备注
			//// );
			//// if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
			//// News.error("四向穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
			//// }
			//// }
			//// // 无异常
			//// } else {
			//// // 异常修复
			//// if (latest != null && latest.getStatus() == 1) {
			//// latest.setEndTime(now);
			//// latest.setUpdateTime(now);
			//// latest.setStatus(2);
			//// if (!basShuttleErrLogService.updateById(latest)) {
			//// News.error("四向穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
			//// }
			//// }
			//// }
			// }
			// }
			// }
			//
			// /**
			// * 提升机异常信息记录
			// */
			// private void recLiftErr() {
			// Date now = new Date();
			// for (LiftSlave liftSlave : slaveProperties.getLift()) {
			// // 获取提升机信息
			// LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
			// if (liftThread == null) {
			// continue;
			// }
			// LiftProtocol liftProtocol = liftThread.getLiftProtocol();
			// if (liftProtocol == null) {
			// continue;
			// }
			//
			// if (liftProtocol.getTaskNo() != 0) {
			// //有任务
			// BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(liftSlave.getId(), liftProtocol.getTaskNo().intValue());
			// // 有异常
			// if (latest == null) {
			// if (liftProtocol.getDeviceError() != null && liftProtocol.getDeviceError()) {
			// WrkMast wrkMast = wrkMastMapper.selectById(liftProtocol.getTaskNo());
			// if (wrkMast == null) {
			// continue;
			// }
			//
			// String errName = "";
			// if (liftProtocol.getFrontOverrun()) {
			// errName = "前超限";
			// } else if (liftProtocol.getBackOverrun()) {
			// errName = "后超限";
			// } else if (liftProtocol.getLeftOverrun()) {
			// errName = "左超限";
			// } else if (liftProtocol.getRightOverrun()) {
			// errName = "右超限";
			// } else if (liftProtocol.getOverHeight()) {
			// errName = "超高";
			// } else if (liftProtocol.getOverWeight()) {
			// errName = "超重";
			// }
			//
			// BasLiftErrLog basLiftErrLog = new BasLiftErrLog(
			// null, // 编号
			// wrkMast.getWrkNo(), // 工作号
			// now, // 发生时间
			// null, // 结束时间
			// wrkMast.getWrkSts(), // 工作状态
			// wrkMast.getIoType(), // 入出库类型
			// liftSlave.getId(), // 提升机
			// null, // plc
			// wrkMast.getLocNo(), // 目标库位
			// wrkMast.getStaNo(), // 目标站
			// wrkMast.getSourceStaNo(), // 源站
			// wrkMast.getSourceLocNo(), // 源库位
			// wrkMast.getBarcode(), // 条码
			// null, // 异常码
			// errName, // 异常
			// 1, // 异常情况
			// now, // 添加时间
			// null, // 添加人员
			// now, // 修改时间
			// null, // 修改人员
			// "任务中异常", // 备注
			// JSON.toJSONString(liftProtocol) // 系统状态数据
			// );
			// if (!basLiftErrLogService.insert(basLiftErrLog)) {
			// News.error("提升机plc异常记录失败 ===>> [id:{}] [error:{}]", liftSlave.getId(), errName);
			// }
			// }
			// } else {
			// // 异常修复
			// if (liftProtocol.getDeviceError() == null \|\| !liftProtocol.getDeviceError()) {
			// latest.setEndTime(now);
			// latest.setUpdateTime(now);
			// latest.setStatus(2);
			// if (!basLiftErrLogService.updateById(latest)) {
			// News.error("提升机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", liftSlave.getId(), latest.getId());
			// }
			// }
			// }
			// }
			// }
			// }
			/**
			* 异常信息记录
			*/
			public void recErr() {
			try {
			this.recShuttleErr();
			this.recLiftErr();
			} catch (Exception e) {
			News.error("recErr fail", e);
			}
			}

			/**
			* 四向穿梭车异常信息记录
			*/
			private void recShuttleErr() {
			Date now = new Date();
			for (ShuttleSlave shuttleSlave : slaveProperties.getShuttle()) {
			// 获取四向穿梭车信息
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleSlave.getId());
			if (shuttleThread == null) {
			continue;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			continue;
			}

			if (shuttleProtocol.getTaskNo() != 0) {
			//有任务
			BasShuttleErrLog latest = basShuttleErrLogService.findLatestByTaskNo(shuttleSlave.getId(), shuttleProtocol.getTaskNo());
			// 有异常
			if (latest == null) {
			if (shuttleProtocol.getErrorCode() != null && Integer.parseInt(shuttleProtocol.getErrorCode()) != 0) {
			WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
			if (wrkMast == null) {
			continue;
			}
			int errorCode = Integer.parseInt(shuttleProtocol.getErrorCode());
			BasShuttleErr basShuttleErr = basShuttleErrService.queryByCode(errorCode);
			String errName = basShuttleErr==null? "未知异常":basShuttleErr.getErrName();
			BasShuttleErrLog basShuttleErrLog = new BasShuttleErrLog(
			null, // 编号
			wrkMast.getWrkNo(), // 工作号
			now, // 发生时间
			null, // 结束时间
			wrkMast.getWrkSts(), // 工作状态
			wrkMast.getIoType(), // 入出库类型
			shuttleSlave.getId(), // 四向穿梭车
			null, // plc
			wrkMast.getLocNo(), // 目标库位
			wrkMast.getStaNo(), // 目标站
			wrkMast.getSourceStaNo(), // 源站
			wrkMast.getSourceLocNo(), // 源库位
			wrkMast.getBarcode(), // 条码
			errorCode, // 异常码
			errName, // 异常
			1, // 异常情况
			now, // 添加时间
			null, // 添加人员
			now, // 修改时间
			null, // 修改人员
			"任务中异常", // 备注
			JSON.toJSONString(shuttleProtocol) // 系统状态数据
			);
			if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
			News.error("四向穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
			}
			}
			} else {
			// 异常修复
			if (shuttleProtocol.getErrorCode() == null \|\| Integer.parseInt(shuttleProtocol.getErrorCode()) == 0) {
			latest.setEndTime(now);
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basShuttleErrLogService.updateById(latest)) {
			News.error("四向穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
			}
			}
			}
			}
			}
			}

			/**
			* 提升机异常信息记录
			*/
			private void recLiftErr() {
			Date now = new Date();
			for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
			// 获取提升机信息
			ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
			if (forkLiftThread == null) {
			continue;
			}
			ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
			if (forkLiftProtocol == null) {
			continue;
			}

			if (forkLiftProtocol.getTaskNo() != 0) {
			//有任务
			BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(forkLiftSlave.getId(), forkLiftProtocol.getTaskNo());
			// 有异常
			if (latest == null) {
			if (forkLiftProtocol.getErrorCode() != null && forkLiftProtocol.getErrorCode() != 0) {
			WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
			if (wrkMast == null) {
			continue;
			}

			BasLiftErr basLiftErr = basLiftErrService.queryByCode(forkLiftProtocol.getErrorCode());
			String errName = basLiftErr==null? "未知异常":basLiftErr.getErrName();

			BasLiftErrLog basLiftErrLog = new BasLiftErrLog(
			null, // 编号
			wrkMast.getWrkNo(), // 工作号
			now, // 发生时间
			null, // 结束时间
			wrkMast.getWrkSts(), // 工作状态
			wrkMast.getIoType(), // 入出库类型
			forkLiftSlave.getId(), // 提升机
			null, // plc
			wrkMast.getLocNo(), // 目标库位
			wrkMast.getStaNo(), // 目标站
			wrkMast.getSourceStaNo(), // 源站
			wrkMast.getSourceLocNo(), // 源库位
			wrkMast.getBarcode(), // 条码
			null, // 异常码
			errName, // 异常
			1, // 异常情况
			now, // 添加时间
			null, // 添加人员
			now, // 修改时间
			null, // 修改人员
			"任务中异常", // 备注
			JSON.toJSONString(forkLiftProtocol) // 系统状态数据
			);
			if (!basLiftErrLogService.insert(basLiftErrLog)) {
			News.error("提升机plc异常记录失败 ===>> [id:{}] [error:{}]", forkLiftSlave.getId(), errName);
			}
			}
			} else {
			// 异常修复
			if (forkLiftProtocol.getErrorCode() == null \|\| forkLiftProtocol.getErrorCode() == 0) {
			latest.setEndTime(now);
			latest.setUpdateTime(now);
			latest.setStatus(2);
			if (!basLiftErrLogService.updateById(latest)) {
			News.error("提升机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", forkLiftSlave.getId(), latest.getId());
			}
			}
			}
			}
			}
			}

			// -------------------------------------------------------------------------------

			@@ -1665,419 +1668,305 @@
			// }

			/**
			* 出库 ===>> 工作档信息写入led显示器
			* 四向穿梭车电量检测 ===>> 发起充电
			*/
			public void ledExecute() {
			// try {
			// for (LedSlave led : slaveProperties.getLed()) {
			// // 获取输送线plc线程
			// DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
			// // 命令集合
			// List<LedCommand> commands = new ArrayList<>();
			// // 工作档集合
			// List<WrkMast> wrkMasts = new ArrayList<>();
			// List<WrkMastLog> wrkMastLogs = new ArrayList<>();
			// for (Integer staNo : led.getStaArr()) {
			// // 获取叉车站点
			// StaProtocol staProtocol = devpThread.getStation().get(staNo);
			// if (null == staProtocol \|\| null == staProtocol.getWorkNo() \|\| 0 == staProtocol.getWorkNo() \|\| !staProtocol.isLoading()) {
			// continue;
			// } else {
			// staProtocol = staProtocol.clone();
			// }
			// // 获取工作档数据
			// WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
			// Integer wrkNo = staProtocol.getWorkNo().intValue();
			// Integer ioType = null;
			// String sourceLocNo = null;
			// String locNo = null;
			// Integer wrkStaNo = null;
			// String barcode = null;
			// if (wrkMast == null) {
			// //查询历史档
			// WrkMastLog wrkMastLog = wrkMastLogMapper.selectLatestByWorkNo(staProtocol.getWorkNo().intValue());
			// if (wrkMastLog == null) {
			// continue;
			// }
			// ioType = wrkMastLog.getIoType();
			// sourceLocNo = wrkMastLog.getSourceLocNo();
			// locNo = wrkMastLog.getLocNo();
			// wrkStaNo = wrkMastLog.getStaNo();
			// barcode = wrkMastLog.getBarcode();
			// wrkMastLogs.add(wrkMastLog);
			// }else {
			// if (wrkMast.getWrkSts() < 14 \|\| wrkMast.getIoType() < 100) {
			// continue;
			// }
			// ioType = wrkMast.getIoType();
			// sourceLocNo = wrkMast.getSourceLocNo();
			// locNo = wrkMast.getLocNo();
			// wrkStaNo = wrkMast.getStaNo();
			// barcode = wrkMast.getBarcode();
			// wrkMasts.add(wrkMast);
			// }
			// // 组装命令
			// LedCommand ledCommand = new LedCommand();
			// ledCommand.setWorkNo(wrkNo);
			// ledCommand.setIoType(ioType);
			// // 出库模式
			// switch (ioType) {
			// case 101:
			// ledCommand.setTitle("全板出库");
			// break;
			// case 103:
			// ledCommand.setTitle("拣料出库");
			// break;
			// case 104:
			// ledCommand.setTitle("并板出库");
			// break;
			// case 107:
			// ledCommand.setTitle("盘点出库");
			// break;
			// case 110:
			// ledCommand.setTitle("空板出库");
			// ledCommand.setEmptyMk(true);
			// break;
			// default:
			// News.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkNo, ioType);
			// break;
			// }
			// ledCommand.setSourceLocNo(sourceLocNo);
			// ledCommand.setLocNo(locNo);
			// ledCommand.setStaNo(wrkStaNo);
			// ledCommand.setBarcode(barcode);
			// if (ioType != 110 && ioType != 10) {
			// List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkNo));
			// if (!wrkDetls.isEmpty()) {
			// wrkDetls.forEach(wrkDetl -> {
			// double remainNum = wrkDetl.getStock() - wrkDetl.getAnfme();//剩余数量
			// if (remainNum < 0) {
			// remainNum = 0;
			// }
			// String matnr = wrkDetl.getMatnr();
			// Mat mat = matService.selectByMatnr(wrkDetl.getMatnr());
			// if (mat != null) {
			// if (!mat.getMatnr().equals(mat.getMatnr2())) {
			// matnr += " - " + mat.getMatnr2();
			// }
			// }
			// ledCommand.getMatDtos().add(new MatDto(matnr, wrkDetl.getMaktx(), wrkDetl.getAnfme(), remainNum, wrkDetl.getSpecs(), wrkDetl.getSuppCode(), wrkDetl.getOrderNo()));
			// });
			// }else {
			// List<WrkDetlLog> wrkDetlLogs = wrkDetlLogService.selectLatestByWorkNo(wrkNo, barcode);
			// for (WrkDetlLog wrkDetlLog : wrkDetlLogs) {
			// double remainNum = wrkDetlLog.getStock() - wrkDetlLog.getAnfme();//剩余数量
			// if (remainNum < 0) {
			// remainNum = 0;
			// }
			// String matnr = wrkDetlLog.getMatnr();
			// Mat mat = matService.selectByMatnr(wrkDetlLog.getMatnr());
			// if (mat != null) {
			// if (!mat.getMatnr().equals(mat.getMatnr2())) {
			// matnr += " - " + mat.getMatnr2();
			// }
			// }
			// ledCommand.getMatDtos().add(new MatDto(matnr, wrkDetlLog.getMaktx(), wrkDetlLog.getAnfme(), remainNum, wrkDetlLog.getSpecs(), wrkDetlLog.getSuppCode()));
			// }
			// }
			// commands.add(ledCommand);
			// }
			// Set<Integer> workNos = null;
			// if (!wrkMasts.isEmpty()) {
			// workNos = wrkMasts.stream().map(WrkMast::getWrkNo).collect(Collectors.toSet());
			// }else {
			// workNos = wrkMastLogs.stream().map(WrkMastLog::getWrkNo).collect(Collectors.toSet());
			// }
			// // 获取LED线程
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
			// // 相同工作号集合则过滤
			// if (CollectionUtils.equals(ledThread.getWorkNos(), workNos)) {
			// continue;
			// }
			// // 命令下发 -------------------------------------------------------------------------------
			// if (!commands.isEmpty()) {
			// if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
			// log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			// continue;
			// } else {
			// ledThread.setLedMk(false);
			// }
			// }
			//
			// try {
			// // 修改主档led标记
			// for (WrkMast wrkMast : wrkMasts) {
			// wrkMast.setOveMk("Y");
			// wrkMast.setModiTime(new Date());
			// if (wrkMastMapper.updateById(wrkMast) == 0) {
			// throw new CoolException("更新工作档失败");
			// }
			// }
			//
			// // 更新线程当前工作号集合
			// ledThread.setWorkNos(workNos);
			//
			// } catch (Exception e) {
			// e.printStackTrace();
			// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			// }
			//
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			public synchronized void loopShuttleCharge() {
			try {
			for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			//获取四向穿梭车线程
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			continue;
			}

			//判断当前小车是否满足需要充电要求
			if (!shuttleThread.isRequireCharge()) {
			continue;
			}

			WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttleProtocol.getShuttleNo());
			if (wrkMast != null) {//已有充电任务
			continue;
			}

			//小车所在楼层
			int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
			ShuttleChargeType shuttleCharge = null;

			//搜索小车所在楼层有没有充电桩
			for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
			if (lev != Utils.getLev(chargeType.locNo)) {
			continue;//小车和充电桩不在同一层
			}

			//小车和充电桩在同一层
			if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
			shuttleCharge = chargeType;
			break;
			}
			}

			if (shuttleCharge == null) {
			//同楼层没有找到充电桩，找可用充电桩
			//小车同楼层没有充电桩，只要充电桩可用就生成充电任务
			for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
			if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
			//判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
			int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
			boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
			if (checkLevHasShuttle) {
			//当前充电桩楼层有穿梭车，不分配该充电桩
			continue;
			}

			shuttleCharge = chargeType;
			break;
			}
			}
			}

			if (shuttleCharge == null) {
			continue;
			}

			String chargeLocNo = shuttleCharge.locNo;
			wrkMast = new WrkMast();
			wrkMast.setMk(String.valueOf(shuttleCharge.id));
			wrkMast.setWrkNo(commonService.getWorkNo(WrkIoType.SHUTTLE_CHARGE.id));
			wrkMast.setWrkSts(WrkStsType.NEW_CHARGE.sts);
			wrkMast.setIoType(WrkIoType.SHUTTLE_CHARGE.id);//300.充电
			wrkMast.setIoPri((double) 999);
			wrkMast.setLocNo(chargeLocNo);
			wrkMast.setShuttleNo(shuttle.getId());
			wrkMast.setMemo("charge");
			wrkMast.setAppeTime(new Date());
			if (!wrkMastService.insert(wrkMast)) {
			News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
			continue;
			}

			News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
			}
			} catch (Exception e) {
			e.printStackTrace();
			}
			}

			/**
			* 其他 ===>> LED显示器复位，显示默认信息
			* 执行四向穿梭车充电任务
			*/
			public void ledReset() {
			// try {
			// for (LedSlave led : slaveProperties.getLed()) {
			// // 获取输送线plc线程
			// DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
			// // 命令集合
			// boolean reset = true;
			// for (Integer staNo : led.getStaArr()) {
			// // 获取叉车站点
			// StaProtocol staProtocol = devpThread.getStation().get(staNo);
			// if (staProtocol == null) {
			// continue;
			// }
			// if (staProtocol.isLoading()) {
			// reset = false;
			// break;
			// }
			// }
			// // 获取led线程
			// LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
			// // led显示默认内容
			// if (reset) {
			// ledThread.setLedMk(true);
			// if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
			// log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
			// }
			// }
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			public synchronized void executeShuttleCharge() {
			try {
			//查询小车充电任务
			for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttle.getId());
			if(wrkMast == null) {
			continue;
			}

			boolean result1 = this.executeShuttleChargeStepGoToChargeSta(wrkMast);//小车等待充电桩
			if (!result1) {
			continue;
			}

			boolean result2 = this.executeShuttleChargeStepArrivalChargeSta(wrkMast);//小车到达充电桩
			if (!result2) {
			continue;
			}

			boolean result3 = this.executeShuttleChargeStepStartCharge(wrkMast);//小车开始充电
			if (!result3) {
			continue;
			}

			boolean result4 = this.executeShuttleChargeStepStopCharge(wrkMast);//小车停止充电
			if (!result4) {
			continue;
			}

			boolean result5 = this.executeShuttleChargeStepLeaveCharge(wrkMast);//小车离开充电桩
			if (!result5) {
			continue;
			}
			}
			} catch (Exception e) {
			e.printStackTrace();
			}
			}

			// /**
			// * 四向穿梭车电量检测 ===>> 发起充电
			// */
			// public synchronized void loopShuttleCharge() {
			// try {
			// for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			// //获取四向穿梭车线程
			// NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
			// NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
			// if (shuttleProtocol == null) {
			// continue;
			// }
			//
			// //判断当前小车是否满足需要充电要求
			// if (!shuttleProtocol.isRequireCharge()) {
			// continue;
			// }
			//
			// WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttleProtocol.getShuttleNo().intValue());
			// if (wrkCharge != null) {//已有充电任务
			// continue;
			// }
			//
			// //小车所在楼层
			// int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
			// ShuttleChargeType shuttleCharge = null;
			//
			// //搜索小车所在楼层有没有充电桩
			// for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
			// if (lev != Utils.getLev(chargeType.locNo)) {
			// continue;//小车和充电桩不在同一层
			// }
			//
			// //小车和充电桩在同一层
			// if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
			// shuttleCharge = chargeType;
			// break;
			// }
			// }
			//
			// if (shuttleCharge == null) {
			// //同楼层没有找到充电桩，找可用充电桩
			// //小车同楼层没有充电桩，只要充电桩可用就生成充电任务
			// for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
			// if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
			// //判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
			// int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
			// boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
			// if (checkLevHasShuttle) {
			// //当前充电桩楼层有穿梭车，不分配该充电桩
			// continue;
			// }
			//
			// shuttleCharge = chargeType;
			// break;
			// }
			// }
			// }
			//
			// if (shuttleCharge == null) {
			// continue;
			// }
			//
			// String chargeLocNo = shuttleCharge.locNo;
			// wrkCharge = new WrkCharge();
			// wrkCharge.setShuttleNo(shuttle.getId());
			// wrkCharge.setCharge(shuttleCharge.id);
			// wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
			// wrkCharge.setWrkSts(51L); // 51.准备充电
			// wrkCharge.setIoPri((double) 10);
			// wrkCharge.setLocNo(chargeLocNo);
			// wrkCharge.setMemo("charge");
			// wrkCharge.setAppeTime(new Date());
			// if (!wrkChargeService.insert(wrkCharge)) {
			// News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
			// continue;
			// }
			//
			// News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			// }
			//
			// /**
			// * 执行四向穿梭车充电任务
			// */
			// public synchronized void executeShuttleCharge() {
			// try {
			// for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
			// WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttle.getId());
			// if (wrkCharge == null) {
			// continue;
			// }
			//
			// NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
			// if (shuttleThread == null) {
			// continue;
			// }
			// NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
			// if (shuttleProtocol == null) {
			// continue;
			// }
			//
			// if (wrkCharge.getWrkSts() == 51) {
			// if (!shuttleProtocol.isIdleNoCharge()) {
			// continue;
			// }
			//
			// if (shuttleProtocol.getSuspendState() == 1) {
			// continue;//管制中
			// }
			//
			// if (!shuttleProtocol.getCurrentLocNo().equals(wrkCharge.getLocNo())) {
			// //小车不在充电桩位置
			// shuttleDispatchUtils.dispatchShuttle(wrkCharge.getWrkNo(), wrkCharge.getLocNo(), shuttle.getId());//调度小车去充电桩
			// continue;
			// }
			//
			// //小车已经在充电桩位置，下发充电命令
			// NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), true);
			// ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
			// commands.add(chargeCommand);
			// //创建分配命令
			// ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			// assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
			// assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
			// assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
			// assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
			// assignCommand.setCommands(commands);//运行命令
			//
			// wrkCharge.setWrkSts(52L);//51.生成充电任务 => 52.小车去充电中
			// wrkCharge.setModiTime(new Date());
			// if (wrkChargeMapper.updateById(wrkCharge) > 0) {
			// //下发任务
			// MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
			// }
			// } else if (wrkCharge.getWrkSts() == 52) {
			// //检测小车是否满电
			//
			// //获取满电阈值
			// int maxPower = 95;
			// EntityWrapper<Config> wrapper = new EntityWrapper<>();
			// wrapper.eq("code", "chargeMaxValue");
			// Config config = configService.selectOne(wrapper);
			// if (config != null) {
			// maxPower = Integer.parseInt(config.getValue());
			// }
			//
			// if (shuttleProtocol.getPowerPercent() < maxPower) {
			// continue;
			// }
			//
			// //*************判断是否满充校准*************
			// EntityWrapper<Config> wrapper1 = new EntityWrapper<>();
			// wrapper.eq("code", "shuttleMaxPowerVerify");
			// Config config1 = configService.selectOne(wrapper1);
			// if (config1 != null) {
			// if (config1.getValue().equals("true")) {
			// if (shuttleProtocol.getVoltage() < 5630) {
			// continue;//电压不够继续充电
			// }
			// }
			// }
			// //*************判断是否满充校准*************
			//
			// //小车满电，结束充电任务
			// NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), false);
			// ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
			// commands.add(chargeCommand);
			// //创建分配命令
			// ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			// assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
			// assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
			// assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
			// assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
			// assignCommand.setCommands(commands);//运行命令
			//
			// //下发任务
			// MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
			// try {
			// Thread.sleep(3000);
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			//
			// wrkCharge.setWrkSts(53L);//52.小车去充电中 => 53.小车充电完成
			// wrkCharge.setModiTime(new Date());
			// if (wrkChargeMapper.updateById(wrkCharge) > 0) {
			// shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE.id);
			// shuttleProtocol.setTaskNo(0);
			// shuttleProtocol.setPakMk(false);
			// }
			// } else if (wrkCharge.getWrkSts() == 53) {
			// if (shuttleProtocol.getChargState() == 0) {//小车处于未充电状态
			// boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkCharge.getLocNo()), shuttleThread.getSlave().getId(), shuttleThread);
			// if (!result) {
			// continue;
			// }
			//
			// wrkCharge.setWrkSts(60L);//53.小车充电完成 => 60.充电任务完成
			// wrkCharge.setModiTime(new Date());
			// if (wrkChargeMapper.updateById(wrkCharge) > 0) {
			//
			// }
			// }
			// }
			//
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			// }
			/**
			* 小车前往充电桩
			*/
			private synchronized boolean executeShuttleChargeStepGoToChargeSta(WrkMast wrkMast) {
			if (wrkMast.getWrkSts() == WrkStsType.NEW_CHARGE.sts) {
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
			//小车在充电桩位置
			wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);
			wrkMast.setModiTime(new Date());
			wrkMastService.updateById(wrkMast);
			return false;
			}

			//调度小车去充电桩
			boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getLocNo(), wrkMast.getShuttleNo());
			if (!dispatched) {
			return false;
			}

			wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN.sts);//小车前往充电桩
			wrkMast.setModiTime(new Date());
			wrkMastService.updateById(wrkMast);
			return false;
			}
			return true;
			}

			/**
			* 小车到达充电桩
			*/
			private synchronized boolean executeShuttleChargeStepArrivalChargeSta(WrkMast wrkMast) {
			if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN.sts) {
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			//判断是否存在未完成的移动任务
			WrkMast moveWrk = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
			if(moveWrk != null) {
			return false;
			}

			if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
			return false;
			}

			//小车在充电桩位置
			wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);//小车到达充电桩
			wrkMast.setModiTime(new Date());
			wrkMastService.updateById(wrkMast);

			return false;
			}
			return true;
			}

			//小车开始充电
			private synchronized boolean executeShuttleChargeStepStartCharge(WrkMast wrkMast) {
			if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts) {
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			//小车已经在充电桩位置，下发充电命令
			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
			assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
			assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
			assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

			List<ShuttleCommand> commands = shuttleOperaUtils.getShuttleChargeCommand(assignCommand, shuttleThread, true);
			assignCommand.setCommands(commands);//运行命令

			wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_WORKING.sts);
			wrkMast.setModiTime(new Date());
			if (!wrkMastService.updateById(wrkMast)) {
			return false;
			}

			//下发任务
			shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);

			notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_POWER_START);//触发通知
			return false;
			}
			return true;
			}

			//小车停止充电
			private synchronized boolean executeShuttleChargeStepStopCharge(WrkMast wrkMast) {
			if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			if (!shuttleThread.isChargingCompleted()) {
			return false;
			}

			//小车已经在充电桩位置，下发停止充电命令
			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
			assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
			assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
			assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

			List<ShuttleCommand> commands = shuttleOperaUtils.getShuttleChargeCommand(assignCommand, shuttleThread, false);
			assignCommand.setCommands(commands);//运行命令

			//下发任务
			shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
			return false;
			}
			return true;
			}

			//小车离开充电桩
			private synchronized boolean executeShuttleChargeStepLeaveCharge(WrkMast wrkMast) {
			if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts) {
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			ShuttleChargeType chargeType = ShuttleChargeType.get(Integer.parseInt(wrkMast.getMk()));
			if(chargeType == null) {
			return false;
			}

			//调度小车去待机位
			boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), chargeType.waitLocNo, wrkMast.getShuttleNo());
			if (!dispatched) {
			return false;
			}

			wrkMast.setWrkSts(WrkStsType.COMPLETE_CHARGE.sts);
			wrkMast.setModiTime(new Date());
			if (wrkMastService.updateById(wrkMast)) {
			return false;
			}
			return false;
			}
			return true;
			}

			/**
			* 执行小车移库任务
			@@ -2094,6 +1983,11 @@

			boolean stepLiftMove = this.shuttleMoveExecuteStepLiftMove(wrkMast);//提升机搬运中
			if (!stepLiftMove) {
			continue;
			}

			boolean updateShuttleLocation = this.shuttleMoveExecuteStepUpdateShuttleLocation(wrkMast);//提升机搬运完成更新小车坐标
			if (!updateShuttleLocation) {
			continue;
			}

			@@ -2131,7 +2025,7 @@

			//小车处于空闲状态
			if (!shuttleThread.isIdle()) {
			News.info("{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;
			}

			@@ -2155,24 +2049,9 @@
			//判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
			WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftSta.getLiftNo());
			if (liftWrkMast != null) {
			News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftSta.getLiftNo());
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftSta.getLiftNo());
			return false;//当前提升机存在未完成任务，等待下一次轮询
			}

			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
			assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
			assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
			assignCommand.setAuto(true);//自动模式

			//获取小车到输送站点行走命令
			List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
			if (commands == null) {
			News.info("{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;//路径解锁失败
			}

			assignCommand.setCommands(commands);

			//***********尝试锁定目标站路径*************
			List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
			@@ -2192,13 +2071,34 @@
			}
			//***********尝试锁定目标站路径*************

			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
			assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
			assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
			assignCommand.setAuto(true);//自动模式

			//获取小车到输送站点行走命令
			List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
			if (commands == null) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());

			//所使用的路径进行锁定禁用
			navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), shuttleProtocol.getShuttleNo(), targetNodes, false);
			return false;//路径解锁失败
			}

			assignCommand.setCommands(commands);

			wrkMast.setWrkSts(WrkStsType.MOVE_SITE.sts);//小车移动到提升机中 301.生成小车移库任务 ==> 302.小车移动至站点
			wrkMast.setModiTime(now);
			wrkMast.setLiftNo(liftSta.getLiftNo());//提前锁定提升机
			wrkMast.setSystemMsg("");//清空消息
			// shuttleProtocol.setToken(wrkMast.getWrkNo());//独占该小车令牌
			if (wrkMastService.updateById(wrkMast)) {
			//下发任务
			shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
			//触发通知
			notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_MOVING);
			return false;
			}
			return false;
			@@ -2226,14 +2126,14 @@
			return false;
			}
			if (!forkLiftThread.isIdle()) {
			News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
			return false;
			}
			//判断提升机是否有其他任务
			WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
			if (liftWrkMast != null) {
			if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
			News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
			return false;//当前提升机存在未完成任务，等待下一次轮询
			}
			}
			@@ -2243,10 +2143,14 @@
			//获取目标站
			ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
			if (sourceLiftSta == null \|\| liftSta == null) {
			News.info("{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
			return false;//缺少站点信息
			}

			if (liftSta.getHasTray()) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘，禁止派发", wrkMast.getWrkNo());
			return false;//有托盘跳过
			}

			//获取提升机命令
			List<ForkLiftCommand> liftCommands = forkLiftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getLev(), liftSta.getLev());
			@@ -2261,10 +2165,65 @@
			assignCommand.setTaskMode(ForkLiftTaskModeType.SHUTTLE_SWITCH.id.shortValue());

			wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//提升机搬运中 303.小车移动至站点完成 ==> 306.提升机搬运中
			wrkMast.setSystemMsg("");//清空消息
			wrkMast.setModiTime(now);
			if (wrkMastService.updateById(wrkMast)) {
			//下发任务
			forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
			}
			}
			return true;
			}

			/**
			* 小车迁移-提升机搬运完成更新小车坐标
			* 如需主方法执行continue，请返回false
			* ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
			*/
			private boolean shuttleMoveExecuteStepUpdateShuttleLocation(WrkMast wrkMast) {
			//--------------------------------------提升机搬运中-----------------------------------------//
			Date now = new Date();

			//提升机搬运中 307.提升机搬运完成 ==> 308.小车迁出提升机中
			if (wrkMast.getWrkSts() == WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts) {
			//获取四向穿梭车线程
			ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
			if (shuttleThread == null) {
			return false;
			}
			ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
			if (shuttleProtocol == null) {
			return false;
			}

			//小车处于空闲状态
			if (!shuttleThread.isIdle()) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;
			}

			ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
			assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
			assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//更新坐标
			assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
			assignCommand.setAuto(true);//自动模式
			assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
			assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

			//更新小车坐标
			ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
			ArrayList<ShuttleCommand> commands = new ArrayList<>();
			commands.add(command);

			assignCommand.setCommands(commands);

			wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT.sts);//小车迁出提升机中
			wrkMast.setSystemMsg("");//清空消息
			wrkMast.setModiTime(now);

			if (wrkMastService.updateById(wrkMast)) {
			//下发任务
			shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
			}
			}
			return true;
			@@ -2294,7 +2253,7 @@

			//小车处于空闲状态
			if (!shuttleThread.isIdle()) {
			News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;
			}

			@@ -2304,17 +2263,6 @@
			wrkMast.setLiftNo(null);//释放提升机
			wrkMast.setModiTime(now);
			wrkMastService.updateById(wrkMast);

			if (wrkMast.getWrkSts() == WrkStsType.COMPLETE_MOVE.sts) {
			// 保存工作主档历史档
			if (wrkMastLogMapper.save(wrkMast.getWrkNo()) <= 0) {
			log.info("保存工作历史档[workNo={}]失败", wrkMast.getWrkNo());
			}
			// 删除工作主档
			if (!wrkMastService.deleteById(wrkMast)) {
			log.info("删除工作主档[workNo={}]失败", wrkMast.getWrkNo());
			}
			}
			return false;
			}

			@@ -2329,51 +2277,33 @@
			List<ShuttleCommand> commands = null;
			//跨楼层移动任务
			if (Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
			// //需要将前两个节点作为白名单节点传入
			// //获取目标站
			// LiftStaProtocol liftSta = NyLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
			// if (liftSta == null) {
			// return false;//找不到站点
			// }
			//
			// List<NavigateNode> targetNodes = NyLiftUtils.getLiftStaNodes(liftSta.getStaNo());
			// if (targetNodes == null) {
			// return false;//未获取到节点
			// }
			//
			// //设置计算节点的白名单
			// ArrayList<int[]> whiteList = new ArrayList<>();//设置计算节点的白名单
			// for (NavigateNode node : targetNodes) {
			// whiteList.add(new int[]{node.getX(), node.getY()});
			// }
			// commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread, whiteList);
			//需要将前两个节点作为白名单节点传入
			List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
			if (targetNodes == null) {
			return false;//未获取到节点
			}

			//设置计算节点的白名单
			ArrayList<int[]> whiteList = new ArrayList<>();//设置计算节点的白名单
			for (NavigateNode node : targetNodes) {
			whiteList.add(new int[]{node.getX(), node.getY()});
			}
			commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, whiteList, assignCommand, shuttleThread);
			}else {
			//获取小车到目标库位命令
			commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
			}

			if (commands == null) {
			News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
			return false;//路径计算失败
			}

			assignCommand.setCommands(commands);

			// if (wrkMast.getLiftNo() != null) {
			// LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
			// if (liftThread == null) {
			// return false;
			// }
			// LiftProtocol liftProtocol = liftThread.getLiftProtocol();
			// if (liftProtocol == null) {
			// return false;
			// }
			// if (liftProtocol.getToken().equals(shuttleProtocol.getShuttleNo())) {
			// liftProtocol.setToken(0);//释放提升机令牌
			// }
			// }

			wrkMast.setWrkSts(WrkStsType.MOVE_SHUTTLE.sts);//小车移动到目标库位中 309.小车迁出提升机完成 ==> 310.小车移动中
			wrkMast.setLiftNo(null);//释放提升机
			wrkMast.setSystemMsg("");//清空消息
			wrkMast.setModiTime(now);

			if (wrkMastService.updateById(wrkMast)) {
			@@ -2383,41 +2313,5 @@
			}
			return true;
			}

			// //扫描设备PakMk标记是否超时
			// public synchronized void scanDevicePakMk() {
			// try {
			// //扫描小车
			// for (ShuttleSlave slave : slaveProperties.getShuttle()) {
			// NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
			// NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
			// if (shuttleProtocol == null) {
			// continue;
			// }
			//
			// if ((System.currentTimeMillis() - shuttleProtocol.getSendTime() > (1000 * 60 * 5)) && shuttleProtocol.getPakMk()) {
			// //设备超过5分钟还没复位标记
			// shuttleProtocol.setPakMk(false);//复位标记
			// }
			// }
			//
			// //扫描提升机
			// for (LiftSlave slave : slaveProperties.getLift()) {
			// LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, slave.getId());
			// LiftProtocol liftProtocol = liftThread.getLiftProtocol();
			// if (liftProtocol == null) {
			// continue;
			// }
			//
			// if ((System.currentTimeMillis() - liftProtocol.getSendTime() > (1000 * 60 * 5)) && liftProtocol.getPakMk()) {
			// //设备超过5分钟还没复位标记
			// liftProtocol.setPakMk(false);//复位标记
			// }
			// }
			// } catch (Exception e) {
			// e.printStackTrace();
			// }
			//
			// }

			}