zy-wcs.git - Gitblit

			@@ -1,25 +1,23 @@
			package com.zy.asrs.service.impl;

			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			import com.core.common.Cools;
			import com.core.common.R;
			import com.core.exception.CoolException;
			import com.zy.asrs.controller.CrnController;
			import com.zy.asrs.controller.OpenController;
			import com.zy.asrs.controller.SiteController;
			import com.zy.asrs.domain.enums.TaskStatusType;
			import com.zy.asrs.domain.enums.WorkNoType;
			import com.zy.asrs.domain.param.CrnOperatorParam;
			import com.zy.asrs.entity.*;
			import com.zy.asrs.entity.param.TaskOverToWms;
			import com.zy.asrs.mapper.*;
			import com.zy.asrs.entity.wms.StorageEscalationParam;
			import com.zy.asrs.mapper.BasCrnErrorMapper;
			import com.zy.asrs.mapper.StaDescMapper;
			import com.zy.asrs.mapper.TaskWrkMapper;
			import com.zy.asrs.mapper.WrkMastMapper;
			import com.zy.asrs.service.*;
			import com.zy.asrs.utils.CommandUtils;
			import com.zy.asrs.utils.Utils;
			import com.zy.common.service.CommonService;
			import com.zy.common.utils.HttpHandler;
			import com.zy.core.CrnThread;
			import com.zy.core.DevpThread;
			import com.zy.core.cache.MessageQueue;
			@@ -28,15 +26,12 @@
			import com.zy.core.model.CrnSlave;
			import com.zy.core.model.DevpSlave;
			import com.zy.core.model.Task;
			import com.zy.core.model.command.CommandPackage;
			import com.zy.core.model.command.CrnCommand;
			import com.zy.core.model.protocol.CrnProtocol;
			import com.zy.core.model.protocol.StaProtocol;
			import com.zy.core.properties.SlaveProperties;
			import com.zy.core.thread.BarcodeThread;
			import com.zy.core.thread.SiemensDevpThread;
			import com.zy.system.entity.Config;
			import com.zy.system.service.ConfigService;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			@@ -45,7 +40,9 @@
			import org.springframework.transaction.interceptor.TransactionAspectSupport;

			import java.io.IOException;
			import java.util.*;
			import java.util.Date;
			import java.util.List;
			import java.util.Random;

			/**
			* 立体仓库WCS系统主流程业务
			@@ -65,6 +62,8 @@
			@Autowired
			private LocMastService locMastService;
			@Autowired
			private LocDetlService locDetlService;
			@Autowired
			private BasCrnpService basCrnpService;
			@Autowired
			private BasDevpService basDevpService;
			@@ -74,47 +73,50 @@
			private BasCrnErrorMapper basCrnErrorMapper;
			@Autowired
			private TaskWrkMapper taskWrkMapper;

			@Autowired
			private TaskWrkService taskWrkService;
			@Autowired
			private ConfigService configService;
			private CommonService commonService;
			@Autowired
			private StaDescMapper staDescMapper;
			@Autowired
			private CommandInfoService commandInfoService;

			@Autowired
			private OpenServiceImpl openServiceImpl;

			@Autowired
			private StaDescService staDescService;

			@Autowired
			private ApiLogService apiLogService;
			@Autowired
			private CommonService commonService;

			@Value("${wms.url}")
			private String wmsUrl;
			@Value("${wms.inboundTaskApplyPath}")
			private String inboundTaskApplyPath;
			@Value("${wms.movePath}")
			private String movePath;
			@Value("${wms.taskStatusFeedbackPath}")
			private String taskStatusFeedbackPath;
			@Autowired
			private ToWmsService toWmsService;


			@Autowired
			private CrnController crnController;

			@Autowired
			private SiteController siteController;
			private TransferTaskService transferTaskService;

			@Autowired
			private WrkMastService wrkMastService;

			@Autowired
			private WrkDetlService wrkDetlService;

			@Value("${loc-move.enable}")
			private boolean enable;

			@Value("${config.outloading}")
			private boolean outloading;


			public void generateStoreWrkFile() throws IOException, InterruptedException {
			public synchronized void generateStoreWrkFile() {
			try {


			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历入库口
			for (DevpSlave.Sta inSta : devp.getInSta()) {
			StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
			storageEscalationParam.setStationCode(inSta.getStaNo());
			// 获取入库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			@@ -124,8 +126,6 @@
			staProtocol = staProtocol.clone();
			}
			Short workNo = staProtocol.getWorkNo();
			Short stano = staProtocol.getStaNo();

			// 尺寸检测异常
			boolean back = false;
			String errMsg = "";
			@@ -157,222 +157,62 @@
			errMsg = "扫码失败";
			back = true;
			}
			// 退回
			if (back) {
			if (stano == inSta.getBackSta().shortValue()){
			continue;
			}
			if (workNo == 0 && stano == 0){
			continue;
			}
			if (!staProtocol.isPakMk()){
			continue;
			}
			// News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
			staProtocol.setWorkNo(workNo);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			if (taskWrk != null) {
			taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			taskWrkMapper.updateById(taskWrk);
			}
			continue;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing() && staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && (workNo == 9991 )
			&& staProtocol.isPakMk()) {
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && workNo >= 9000 && staProtocol.isPakMk()) {
			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			if (barcodeThread == null) {
			continue;
			}
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode) && !barcode.equals("99999999")) {
			// 请求wms接口，获取工作号和目标库位
			ToWmsDTO toWmsDTO = new ToWmsDTO(barcode,staProtocol.getSiteId(),staProtocol.isHigh() ? 2 : 1);
			TaskWrk taskWrk1=taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode",barcode));
			if(!Cools.isEmpty(taskWrk1)){
			log.info("托盘码："+barcode+"任务档存在");
			if (taskWrk1.getIoType()==1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())){
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk1.getCrnNo()).eq("type_no",1).eq("stn_no",staProtocol.getSiteId()));
			if (Cools.isEmpty(staDesc)){
			log.info("托盘码："+barcode+"任务档存在");
			return;
			}else {
			staProtocol.setWorkNo(taskWrk1.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}
			}
			return;
			}
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("Content-Type","application/json");
			String response;
			try{
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(inboundTaskApplyPath)
			.setJson(JSON.toJSONString(toWmsDTO))
			.build()
			.doPost();
			}catch (Exception e){
			log.error("请求入库调用接口失败");
			log.error("异常信息打印："+e);
			try{
			BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
			if (Cools.isEmpty(basDevp)){
			log.error("站点号异常"+inSta.getStaNo());
			} else if (basDevp.getStaErr()!=0){
			basDevp.setStaErr(2);
			basDevpService.updateById(basDevp);
			}
			}catch (Exception e1){
			// 退回
			log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e1);
			}
			staProtocol.setWorkNo((short)9999);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			// if (taskWrk != null) {
			// taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			// taskWrkMapper.updateById(taskWrk);
			// }
			continue;
			}

			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wms请求入库货位接口"
			,wmsUrl+inboundTaskApplyPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(toWmsDTO)
			,response
			,true
			);
			log.info("入库请求参数{}" + JSON.toJSONString(toWmsDTO));
			log.info("入库请求返回参数{}" + JSON.toJSONString(response));
			if (jsonObject.getInteger("code").equals(200) && !Cools.isEmpty(jsonObject.get("data").toString())) {
			GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
			try{
			BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
			if (Cools.isEmpty(basDevp)){
			log.error("站点号异常1"+inSta.getStaNo());
			throw new CoolException("站点号异常1,未查询到站点信息"+inSta.getStaNo());
			}
			Integer staNoCrnNo = Utils.StaNoCrnNo(inSta.getStaNo());
			if (staNoCrnNo==0){
			basDevp.setStaErr(1);
			basDevpService.updateById(basDevp);
			log.error("站点号异常2"+inSta.getStaNo());
			throw new CoolException("站点号异常2,站点号不存在"+inSta.getStaNo());
			}else {
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("crn_no", staNoCrnNo.longValue())
			.eq("loc_no", getWmsDto.getLocNo()));
			if (Cools.isEmpty(locMast)){
			basDevp.setStaErr(1);
			basDevpService.updateById(basDevp);
			log.error("站点号异常3"+inSta.getStaNo());
			throw new CoolException("站点号异常3：此巷道不存在目标库位"+inSta.getStaNo());
			}
			}
			} catch (Exception e){
			// log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e);
			// 退回
			log.error("扫码检测程序异常"+inSta.getStaNo()+errMsg);
			log.error("扫码检测程序异常,异常信息"+e);

			staProtocol.setWorkNo((short)9999);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			// if (taskWrk != null) {
			// taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			// taskWrkMapper.updateById(taskWrk);
			// }
			continue;
			}
			//查看该库位是否为空库位
			LocMast locMast=locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("loc_sts","O")
			.eq("loc_no",getWmsDto.getLocNo()));
			if(Cools.isEmpty(locMast)){
			try{
			HashMap<String, Object> headParam1 = new HashMap<>();
			headParam1.put("taskNo",getWmsDto.getTaskNo());
			headParam1.put("status",6);
			headParam1.put("ioType",1);
			headParam1.put("barcode",barcode);
			String response2;
			response2 = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam1))
			.build()
			.doPost();
			JSONObject jsonObject1 = JSON.parseObject(response2);
			apiLogService.save("wcs派发库位==》不为空《==上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam1)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs派发库位==》不为空《==上报wms", getWmsDto.getWrkNo());
			throw new CoolException("wcs派发入库任务上报wms失败,派发库位==》不为空《==，异常信息："+e);
			}
			}

			// 创新一个入库工作档
			TaskWrk taskWrk = taskWrkService.selectByTaskNo(getWmsDto.getWrkNo());
			if(Cools.isEmpty(taskWrk)) {
			taskWrk = createTask(getWmsDto,barcode);
			if (Cools.isEmpty(taskWrk)){
			log.error("库位异常，库位号：{}", getWmsDto.getTargetLocationCode());
			}else {
			taskWrkService.insert(taskWrk);
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).eq("stn_no",staProtocol.getSiteId()));
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}
			}

			}else {
			continue;
			}

			String BoxNo = barcodeThread.getBarcode();
			if (Cools.isEmpty(BoxNo)) {
			log.error("{}号条码扫描失败，值：{}", inSta.getBarcode(), BoxNo);
			continue;
			}
			TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", BoxNo));
			if (!Cools.isEmpty(taskWrk1)) {
			log.info("托盘码：" + BoxNo + "任务档存在");
			continue;
			}
			if (back) {
			storageEscalationParam.setWCSStatus(1);
			storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + errMsg);
			}
			storageEscalationParam.setBarcode(BoxNo);
			storageEscalationParam.setMatIdList(staProtocol.getMatIdList());
			storageEscalationParam.setFullPlt(staProtocol.isFullPlt() ? 1 : 0);
			storageEscalationParam.setMpHigh((short) (staProtocol.getSiteId() < 200 ? 1 :staProtocol.isHigh() ? 2 : staProtocol.isLow() ? 1 : 0)); // 高度，侧面码盘的高度低1，高2
			log.info("组托入库={}", storageEscalationParam);
			TaskWrk taskWrk = toWmsService.getLocNoFromWms(storageEscalationParam);
			if (taskWrk == null) {
			log.error("入库请求wms创建任务工作档为空：{}", storageEscalationParam);
			continue;
			} else {
			// 退回
			log.error("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);

			staProtocol.setWorkNo((short)9999);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			if (taskWrk != null) {
			taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			taskWrkMapper.updateById(taskWrk);
			if (-1 == taskWrk.getWrkNo()) {
			back = true;
			}
			}
			if (back) {
			staProtocol.setWorkNo((short) 9991);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			log.info("组托入库托盘退回命令推送输送线队列成功==>{}，{}，{}", BoxNo, errMsg, taskWrk.getWrkNo());
			} else {
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
			if (staDesc == null) {
			log.error("组托入库路径不存在，wrkNo={},crn={},stn_no={}", taskWrk.getWrkNo(), taskWrk.getCrnNo(), staProtocol.getSiteId());
			continue;
			}
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			log.info("组托入库命令推送输送线队列成功:{}", staProtocol);
			}

			}


			}
			}
			} catch (Exception e) {
			@@ -389,40 +229,87 @@
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			// 遍历堆垛机出库站
			for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
			List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));
			for (StaDesc staDesc : staDescs){
			try{
			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == 0)) {
			try {
			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == 0)) {
			if (crnStn.getStaNo() >= 200) {
			// 查询工作档
			TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
			TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), String.valueOf(crnStn.getStaNo() + 2));
			if (taskWrk == null) {
			continue;
			}
			log.info("下发输送线任务：taskWrk:"+JSON.toJSONString(taskWrk));
			R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
			JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(r));
			if (jsonObject.getInteger("code").equals(200)){
			log.info("下发输送线任务成功：taskWrk:"+JSON.toJSONString(taskWrk));
			log.info("下发输送线任务：taskWrk:" + JSON.toJSONString(taskWrk));
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(Short.valueOf(taskWrk.getTargetPoint()));
			staProtocol.setBarcode(taskWrk.getBarcode());
			if (!Cools.isEmpty(taskWrk.getType())) {
			staProtocol.setHeight(taskWrk.getType());
			}
			boolean offer = false;
			try {
			offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
			staProtocol.setMp(taskWrk.getMp());
			staProtocol.setLx(taskWrk.getLx());
			staProtocol.setLev(taskWrk.getLev());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(3, staProtocol));
			} catch (Exception e) {
			log.error("下发输送线任务失败：异常:" + e);
			log.error("下发输送线任务失败：异常:offer:" + offer);
			}
			if (offer) {
			log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(taskWrk));
			taskWrk.setStatus(5);
			taskWrk.setWrkSts(14);
			taskWrk.setCompleteTime(new Date());
			taskWrkService.updateById(taskWrk);
			}else {
			log.error("下发输送线任务失败：taskWrk:"+JSON.toJSONString(taskWrk));
			log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));

			} else {
			log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
			}
			} else {
			// 查询工作档
			TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), String.valueOf(crnStn.getStaNo() - 1));
			if (taskWrk == null) {
			continue;
			}
			log.info("下发输送线任务：taskWrk:" + JSON.toJSONString(taskWrk));
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(Short.valueOf(taskWrk.getTargetPoint()));
			if (!Cools.isEmpty(taskWrk.getType())) {
			staProtocol.setHeight(taskWrk.getType());
			}
			boolean offer = false;
			try {
			offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
			} catch (Exception e) {
			log.error("下发输送线任务失败：异常:" + e);
			log.error("下发输送线任务失败：异常:offer:" + offer);
			}
			if (offer) {
			log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(taskWrk));
			taskWrk.setStatus(5);
			taskWrk.setWrkSts(14);
			taskWrk.setCompleteTime(new Date());
			taskWrkService.updateById(taskWrk);

			} else {
			log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
			}
			}
			}catch (Exception e){
			log.error("出库到出库站异常:异常信息："+e);

			// }
			}
			} catch (Exception e) {
			log.error("出库到出库站异常:异常信息：" + e);
			}
			// }

			}
			}
			@@ -436,15 +323,14 @@
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			if (crnProtocol == null) {
			continue;
			}
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}

			// 库位移转
			this.locToLoc(crn, crnProtocol);

			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
			@@ -469,6 +355,8 @@
			crnProtocol.setLastIo("O");
			}
			}
			// 库位移转
			this.locToLoc(crn, crnProtocol);
			}

			}
			@@ -497,7 +385,7 @@
			continue;
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
			&& staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
			&& staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
			flag = true;
			}
			if (!flag) {
			@@ -506,7 +394,18 @@

			// 获取工作状态为2（设备上走）的入库工作档
			TaskWrk taskWrk = taskWrkMapper.selectPakIn(slave.getId(), staProtocol.getWorkNo().intValue(), staDesc.getStnNo().toString());
			if(null == taskWrk) {
			if (null == taskWrk) {
			continue;
			}

			LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
			if (!locMast.getLocSts().equals("O")) {
			if (taskWrk.getWrkSts() == 2) {
			log.error("入库WMS分配库位{}有误，库位状态为{}", locMast.getLocNo(), locMast.getLocSts());
			taskWrk.setWrkSts(5);
			taskWrk.setMemo("WMS分配库位有误");
			taskWrkService.updateById(taskWrk);
			}
			continue;
			}

			@@ -523,42 +422,12 @@
			// int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
			// taskWrk.setWrkNo(workNo);//工作号
			taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
			taskWrk.setAssignTime(new Date());//派发时间
			taskWrk.setExecuteTime(new Date());
			// taskWrk.setAssignTime(new Date());//派发时间
			taskWrk.setWrkSts(3);//工作状态 3.吊车入库
			taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
			taskWrk.setModiTime(new Date());
			taskWrk.setModiUser(9988L);

			// //取出命令
			// List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
			// Integer commandStep = taskWrk.getCommandStep();
			// if (commandInfos.isEmpty()) {
			// continue;//命令空
			// }
			// CommandInfo commandInfo = commandInfos.get(commandStep);
			// CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
			// CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
			//
			// if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
			// log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			// } else {
			// // 修改工作档状态 2.设备上走 => 3.吊车入库中
			// Date now = new Date();
			// taskWrk.setWrkSts(3);
			// taskWrk.setModiTime(now);
			// if (taskWrkMapper.updateById(taskWrk) == 0) {
			// log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", taskWrk.getWrkNo());
			// }
			// //开始运行
			// String response = CrnStartRunning(taskWrk);
			// JSONObject jsonObject = JSON.parseObject(response);
			// if (jsonObject.getInteger("code").equals(200)) {
			//
			// }else {
			// log.error("入库开始运行通讯失败,"+jsonObject.get("msg"));
			//
			// }
			// }
			// taskWrk.setModiTime(new Date());
			// taskWrk.setModiUser(9988L);

			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			@@ -572,49 +441,22 @@
			crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint())); // 目标库位列
			crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint())); // 目标库位层
			crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint())); // 目标库位排
			crnCommand.setCommand((short)1);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
			crnCommand.setCommand((short) 1);
			log.info("堆垛机入库任务下发={}", crnCommand);
			if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			throw new CoolException("堆垛机命令生成失败");
			}else{
			try{
			} else {
			try {
			// 上报执行状态
			toWmsService.executionStatusReport(taskWrk.getTaskNo(), taskWrk.getWrkSts());
			taskWrkService.updateById(taskWrk);
			}catch (Exception e){
			} catch (Exception e) {
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", taskWrk.getWrkNo());
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，异常："+e);
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，异常：" + e);
			}
			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wcs派发入库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			} catch (Exception e){
			log.error("wcs派发入库任务上报wms失败", JSON.toJSONString(taskWrk));
			// throw new CoolException("wcs派发入库任务上报wms失败");
			}

			}
			}

			// return;
			}
			}

			@@ -622,17 +464,17 @@
			* 出库 ===>> 库位到堆垛机站
			* 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
			*/
			public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
			public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol) {
			List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
			if (taskWrksInitial.size()==0){
			if (taskWrksInitial.size() == 0) {
			return;
			}
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
			for (StaDesc staDesc : staDescs){
			for (StaDesc staDesc : staDescs) {
			// 获取工作状态为11（生成出库ID）的出库工作档
			List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(),staDesc.getStnNo().toString());
			for (TaskWrk taskWrk : taskWrks){
			List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(), staDesc.getStnNo().toString());
			for (TaskWrk taskWrk : taskWrks) {
			if (taskWrk == null) {
			continue;
			}
			@@ -641,6 +483,36 @@
			log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getStartPoint(), taskWrk.getIoType());
			continue;
			}

			LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
			//判断其库位是否为深库位，如果为深库位找其浅库位是都有货
			int flag = 0;
			if (locMast.getRow1() == 1 \|\| locMast.getRow1() == 5 \|\| locMast.getRow1() == 9) {
			flag = 1;
			} else if (locMast.getRow1() == 4 \|\| locMast.getRow1() == 8 \|\| locMast.getRow1() == 12) {
			flag = 2;
			}
			if (flag == 1) {
			LocMast locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("row1", (locMast.getRow1() + 1))
			.eq("bay1", locMast.getBay1())
			.eq("lev1", locMast.getLev1()).eq("loc_sts", "F"));
			if (!Cools.isEmpty(locMast1)) {
			log.info(locMast.getLocNo() + "出深库位，浅库位有货");
			continue;
			}
			} else if (flag == 2) {
			LocMast locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("row1", (locMast.getRow1() - 1))
			.eq("bay1", locMast.getBay1())
			.eq("lev1", locMast.getLev1()).eq("loc_sts", "F"));
			if (!Cools.isEmpty(locMast1)) {
			log.info(locMast.getLocNo() + "出深库位，浅库位有货");
			continue;
			}
			}


			// 获取堆垛机出库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			@@ -658,7 +530,7 @@
			}

			// 判断堆垛机出库站状态
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
			if (staProtocol.isAutoing() && (outloading \|\| !staProtocol.isLoading()) && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
			&& staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
			// 命令下发区 --------------------------------------------------------------------------

			@@ -671,7 +543,6 @@
			if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
			break;
			}

			CrnCommand command = new CrnCommand();
			command.setCrnNo(taskWrk.getCrnNo()); // 堆垛机编号
			command.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
			@@ -683,50 +554,31 @@
			command.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
			command.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			command.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			command.setCommand((short)1);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command),false)) {
			command.setCommand((short) 1);

			if (Cools.isEmpty(taskWrk.getMarkStart()) \|\| taskWrk.getMarkStart() == 0) {
			toWmsService.addReportLog(taskWrk);
			taskWrk.setMarkStart(1);
			}

			if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command))) {
			log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(command));
			throw new CoolException("堆垛机命令生成失败");
			}else{
			try{
			} else {
			try {
			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			Date now = new Date();
			taskWrk.setWrkSts(12);
			taskWrk.setStatus(2);
			taskWrk.setModiTime(now);
			taskWrk.setExecuteTime(now);
			if (taskWrkMapper.updateById(taskWrk) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			}
			}catch (Exception e){
			// 上报执行状态
			toWmsService.executionStatusReport(taskWrk.getTaskNo(), taskWrk.getWrkSts());
			} catch (Exception e) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，异常："+e);
			}
			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wcs派发出库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs派发出库任务上报wms失败", JSON.toJSONString(taskWrk));
			// throw new CoolException("wcs派发入库任务上报wms失败");
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，异常：" + e);
			}
			}
			}
			@@ -738,23 +590,17 @@
			/**
			* 库位移转
			*/
			public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
			public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			// 获取工作状态为11（生成出库ID）的移库工作档
			List<TaskWrk> taskWrks = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>()
			.eq("crn_no",slave.getId())
			.eq("wrk_sts",11)
			.eq("io_type",3));
			for (TaskWrk taskWrk : taskWrks){
			.eq("crn_no", slave.getId())
			.eq("wrk_sts", 11)
			.eq("io_type", 3)
			.orderBy("io_pri", false));
			for (TaskWrk taskWrk : taskWrks) {

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			// if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
			// String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
			// TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
			// if (!Cools.isEmpty(hallowLocNoTask)){
			// continue;
			// }
			// }

			// 堆垛机控制过滤
			if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			continue;
			@@ -777,8 +623,6 @@
			// 命令下发区 --------------------------------------------------------------------------




			// 1.堆垛机开始移动
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			@@ -792,45 +636,19 @@
			crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint())); // 目标库位列
			crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint())); // 目标库位层
			crnCommand.setCommand((short) 1);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
			if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			Date now = new Date();
			taskWrk.setWrkSts(12);
			taskWrk.setStatus(2);
			taskWrk.setExecuteTime(now);
			taskWrk.setModiTime(now);
			if (taskWrkMapper.updateById(taskWrk) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			}
			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wcs派发移库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs派发移库库任务上报wms失败", taskWrk);
			// throw new CoolException("wcs派发移库库任务上报wms失败");
			}

			toWmsService.addReportLog(taskWrk);
			}
			return;
			}
			@@ -838,53 +656,6 @@

			}

			/**
			* 执行对工作档的完成操作
			*/
			// public void storeFinished() {
			// for (CrnSlave crn : slaveProperties.getCrn()) {
			// // 获取堆垛机信息
			// CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			// CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			// if (crnProtocol == null) { continue; }
			//
			// // 状态：等待确认并且任务完成位 = 1
			// if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
			// //获取入库待确认工作档
			// TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
			// if (Cools.isEmpty(taskWrk)) {
			//// log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			// continue;
			// }
			//
			// //获取指令ID
			// Integer commandId = crnProtocol.getCommandId();
			// CommandInfo commandInfo = new CommandInfo();
			// if (Cools.isEmpty(commandId)){
			// commandInfo = commandInfoService.selectOne(new EntityWrapper<CommandInfo>()
			// .eq("wrk_no",crnProtocol.getTaskNo())
			// .eq("device","Crn"));
			// }else {
			// commandInfo = commandInfoService.selectById(commandId);
			// }
			//
			//
			// if (commandInfo == null) {
			// //指令不存在
			// continue;
			// }
			// if (commandInfo.getCommandStatus() == 3){
			// continue;
			// }
			// commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//指令完成
			// commandInfo.setCompleteTime(new Date());//指令完成时间
			// if (commandInfoService.updateById(commandInfo)) {//修改成功后复位堆垛机
			// // 堆垛机复位
			// crnThread.setResetFlag(true);
			// }
			// }
			// }
			// }

			/**
			* 执行对工作档的完成操作
			@@ -894,24 +665,28 @@
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			if (crnProtocol == null) {
			continue;
			}

			// 状态：等待确认并且任务完成位 = 1
			if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
			//获取入库待确认工作档
			TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
			if (Cools.isEmpty(taskWrk)&&crnProtocol.getTaskNo() !=999) {
			TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(), crnProtocol.getTaskNo().intValue());
			if (Cools.isEmpty(taskWrk) && crnProtocol.getTaskNo() != 999) {
			log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			continue;
			}
			Thread.sleep(300);
			//确认完成信号
			CrnOperatorParam crnOperatorParam=new CrnOperatorParam();
			CrnOperatorParam crnOperatorParam = new CrnOperatorParam();
			crnOperatorParam.setCrnNo(crn.getId());

			crnController.crnTaskComplete(crnOperatorParam);
			if(!Cools.isEmpty(taskWrk)){
			if(taskWrk.getIoType()==1 && taskWrk.getWrkSts()==3){
			R r = crnController.crnTaskComplete(crnOperatorParam);
			Thread.sleep(1000);
			if (!r.get("code").equals(200)) {
			return;
			}
			if (!Cools.isEmpty(taskWrk)) {
			if (taskWrk.getIoType() == 1 && taskWrk.getWrkSts() == 3) {
			taskWrk.setWrkSts(4);//入库完成
			taskWrk.setStatus(5);//完结
			//更新库位状态
			@@ -921,7 +696,7 @@
			locMast.setModiTime(new Date());
			locMast.setModiUser(9999L);
			locMastService.updateById(locMast);
			}else if(taskWrk.getIoType()==2&&taskWrk.getWrkSts()==12){
			} else if (taskWrk.getIoType() == 2 && taskWrk.getWrkSts() == 12) {
			taskWrk.setWrkSts(13);//出库完成
			taskWrk.setStatus(5);//完结
			//更新库位状态
			@@ -931,7 +706,7 @@
			locMast.setModiTime(new Date());
			locMast.setModiUser(9999L);
			locMastService.updateById(locMast);
			}else if(taskWrk.getIoType()==3&&taskWrk.getWrkSts()==12){
			} else if (taskWrk.getIoType() == 3 && taskWrk.getWrkSts() == 12) {
			taskWrk.setWrkSts(4);//入库完成
			taskWrk.setStatus(5);//完结
			//更新库位状态
			@@ -949,43 +724,8 @@
			locMast1.setModiUser(9999L);
			locMastService.updateById(locMast1);
			}
			taskWrk.setCompleteTime(new Date());
			taskWrkService.updateById(taskWrk);


			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			log.error("wcs完结任务上报wms==》", headParam);

			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			log.error("wcs完结任务上报wms==》", response);

			// JSONObject jsonObject = JSON.parseObject(response);
			// log.error("wcs完结任务上报wms==》", jsonObject);

			apiLogService.save("wcs派发入库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs完结任务上报wms失败", taskWrk);
			log.error("wcs完结任务上报wms失败,报错信息：", e);
			// throw new CoolException("wcs派发入库任务上报wms失败");
			}
			}

			}
			@@ -995,7 +735,7 @@
			/**
			* 堆垛机异常信息记录
			*/
			public void recCrnErr(){
			public void recCrnErr() {
			Date now = new Date();
			for (CrnSlave crn : slaveProperties.getCrn()) {
			// 获取堆垛机信息
			@@ -1017,7 +757,7 @@
			continue;
			}
			BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
			String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
			String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
			BasErrLog basErrLog = new BasErrLog(
			null, // 编号
			wrkMast.getWrkNo(), // 工作号
			@@ -1064,7 +804,7 @@
			// 记录新异常
			if (latest == null \|\| (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
			BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
			String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
			String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
			BasErrLog basErrLog = new BasErrLog(
			null, // 编号
			null, // 工作号
			@@ -1079,7 +819,7 @@
			null, // 源站
			null, // 源库位
			null, // 条码
			(int)crnProtocol.getAlarm1(), // 异常码
			(int) crnProtocol.getAlarm1(), // 异常码
			errName, // 异常
			1, // 异常情况
			now, // 添加时间
			@@ -1110,37 +850,17 @@
			}
			}

			//自动派发任务
			public void autoDistribute() {
			Config config = configService.selectByCode("autoDistribute");
			if (config == null) {
			return;
			}

			if (config.getValue().equals("false")) {//判断是否开启自动派发任务
			return;
			}

			for (TaskWrk taskWrk : taskWrkService.selectReceive()) {

			try {
			taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
			} catch (CoolException e) {
			log.info(e.getMessage());
			}
			}
			}

			//agv取放货任务完成
			public synchronized void autoCompleteAGV() {
			List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
			try{
			try {
			Thread.sleep(500);
			}catch (Exception e){
			} catch (Exception e) {

			}

			for (BasDevp basDevp:basDevps){
			for (BasDevp basDevp : basDevps) {
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
			if (staProtocol == null) {
			@@ -1148,202 +868,402 @@
			} else {
			staProtocol = staProtocol.clone();
			}
			if (basDevp.getWrkNo()!=0){
			if (basDevp.getAgvTargetPick()!=0){//取货
			staProtocol.setAgvTypeSign((short)0);
			if (basDevp.getWrkNo() != 0) {
			if (basDevp.getAgvTargetPick() != 0) {//取货
			staProtocol.setAgvTypeSign((short) 0);
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}
			boolean sign = true;
			if (basDevp.getAgvTargetPlace()!=0){
			if (basDevp.getAgvTargetPlace() != 0) {
			sign = false;
			basDevp.setAgvTargetPlace(0);
			basDevpService.updateById(basDevp);
			staProtocol.setAgvTypeSign((short)3);//1
			staProtocol.setAgvTypeSign((short) 3);//1
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}
			}else {
			if (basDevp.getAgvTargetPlace()!=0){
			if (basDevp.getLoading().equals("Y")){
			staProtocol.setAgvTypeSign((short)1);
			} else {
			if (basDevp.getAgvTargetPlace() != 0) {
			if (basDevp.getLoading().equals("Y")) {
			staProtocol.setAgvTypeSign((short) 1);
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}else {
			} else {
			log.error("AGV放货完成但输送线无物，复位信号 ===>> [staNo:{}] [basDevp:{}]", basDevp.getDevNo(), basDevp);
			basDevp.setAgvTargetPlace(0);
			basDevpService.updateById(basDevp);
			staProtocol.setAgvTypeSign((short)3);//1
			staProtocol.setAgvTypeSign((short) 3);//1
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}

			}
			if (basDevp.getAgvTargetPick()!=0){
			if (basDevp.getAgvTargetPick() != 0) {
			basDevp.setAgvTargetPick(0);
			basDevpService.updateById(basDevp);
			staProtocol.setAgvTypeSign((short)2);//0
			staProtocol.setAgvTypeSign((short) 2);//0
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}
			}
			}
			}
			public synchronized void autoCompleteTask() {
			List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
			for (TaskWrk taskWrk : taskWrks) {
			//获取命令集合
			List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
			if (taskWrk.getCommandStep() < commandInfos.size()) {
			continue;//当前步序没有到达最后一条命令
			}

			//判断末端命令是否执行完成
			CommandInfo commandInfo = commandInfos.get(commandInfos.size() - 1);
			if (commandInfo.getCommandStatus() != CommandStatusType.COMPLETE.id) {
			continue;//指令未完成
			}

			Date now = new Date();
			//指令已完成，更新任务
			if (taskWrk.getIoType() == 1) {
			//入库任务
			taskWrk.setWrkSts(4);//3.吊车入库中 => 4.入库完成
			//taskWrk.setStatus(TaskStatusType.COMPLETE.id);
			taskWrk.setModiTime(now);
			taskWrkService.updateById(taskWrk);

			//更新库位状态
			LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
			locMast.setLocSts("F");//F.在库
			locMast.setBarcode(taskWrk.getBarcode());//托盘码
			locMast.setModiTime(now);
			locMast.setModiUser(9999L);
			locMastService.updateById(locMast);
			} else if (taskWrk.getIoType() == 2) {
			//出库任务
			taskWrk.setWrkSts(14);//12.吊车出库中 => 14.出库完成
			// taskWrk.setStatus(TaskStatusType.COMPLETE.id);
			taskWrk.setModiTime(now);
			taskWrkService.updateById(taskWrk);

			//更新库位状态
			LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
			locMast.setLocSts("O");//O.空库位
			locMast.setBarcode("");//托盘码
			locMast.setModiTime(now);
			locMast.setModiUser(9999L);
			locMastService.updateById(locMast);
			}
			}
			}


			public synchronized String CrnStartRunning(TaskWrk taskWrk){
			String tasktype = null;
			switch (taskWrk.getIoType()){
			case 1:
			tasktype= "RK";
			break;
			case 2:
			tasktype= "CK";
			break;
			case 3:
			tasktype= "YK";
			break;
			default:
			tasktype= "未知";
			}
			Map<String, Object> map = new HashMap<>();
			map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
			TaskOverToWms taskOverToWms = new TaskOverToWms();
			taskOverToWms.setFeedbackFrom("WCS"); //来源
			taskOverToWms.setWarehouseId("1688469798893297665"); //仓库标识
			taskOverToWms.setTaskNo(taskWrk.getTaskNo()); //任务号
			taskOverToWms.setTaskType(tasktype); // 任务类型
			taskOverToWms.setContainerCode(taskWrk.getBarcode()); // 容器编码
			if (taskWrk.getIoType() ==1 \|\| taskWrk.getIoType() == 3){
			taskOverToWms.setEquipmentCode(String.valueOf(taskWrk.getCrnNo())); //设备编码
			taskOverToWms.setTargetLocationCode(taskWrk.getOriginTargetPoint()); //目标库位
			}else if (taskWrk.getIoType() ==2){
			Map<Integer,String> map1 = new HashMap<>();
			map1.put(102,"J-1101");
			map1.put(106,"J-1103");
			map1.put(110,"J-1105");
			map1.put(114,"J-1107");
			map1.put(118,"J-1109");
			map1.put(122,"J-1111");
			map1.put(305,"H-1101");
			map1.put(405,"G-1101");
			taskOverToWms.setEquipmentCode(map1.get(taskWrk.getTargetPoint())); //设备编码
			taskOverToWms.setSourceLocationCode(taskWrk.getOriginStartPoint()); //源库位
			}

			taskOverToWms.setTaskStatus("executing"); //任务状态
			String response = null;
			/**
			* 入出库模式切换函数
			*/
			public synchronized void ioConvert() {
			try {
			response = new HttpHandler.Builder()
			.setHeaders(map)
			.setUri(wmsUrl)
			.setPath("wcsManager/wcsInterface/taskStatusFeedback")
			.setJson(JSON.toJSONString(taskOverToWms))
			.build()
			.doPost();
			}catch (Exception e){
			log.error("堆垛机任务完成，请求wms任务完成接口失败");
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			if (devp.getId() == 2) {
			continue;
			}
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			for (DevpSlave.Sta inSta : devp.getInSta()) {
			TaskWrk taskWrk = taskWrkService.selectByTargetPoint(inSta.getBackSta() + "");
			switch (inSta.getBackSta()) {
			case 101:
			if (taskWrk != null) {
			if (devpThread.ioModeOf1F1 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf1F1 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf1F1 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf1F1 = IoModeType.PAKIN_MODE;
			}
			break;
			case 104:
			if (taskWrk != null) {
			if (devpThread.ioModeOf1F2 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf1F2 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf1F2 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf1F2 = IoModeType.PAKIN_MODE;
			}
			break;
			case 107:
			if (taskWrk != null) {
			if (devpThread.ioModeOf1F3 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf1F3 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf1F3 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf1F3 = IoModeType.PAKIN_MODE;
			}
			break;
			case 110:
			if (taskWrk != null) {
			if (devpThread.ioModeOf1F4 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf1F4 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf1F4 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf1F4 = IoModeType.PAKIN_MODE;
			}
			break;
			case 113:
			if (taskWrk != null) {
			if (devpThread.ioModeOf1F5 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf1F5 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf1F5 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf1F5 = IoModeType.PAKIN_MODE;
			}
			break;
			case 203:
			if (taskWrk != null) {
			if (devpThread.ioModeOf2F1 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf2F1 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf2F1 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf2F1 = IoModeType.PAKIN_MODE;
			}
			break;

			case 207:
			if (taskWrk != null) {
			if (devpThread.ioModeOf2F2 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf2F2 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf2F2 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf2F2 = IoModeType.PAKIN_MODE;
			}
			break;

			case 212:
			if (taskWrk != null) {
			if (devpThread.ioModeOf2F3 != IoModeType.PAKOUT_MODE) {
			// 出库切换中
			devpThread.ioModeOf2F3 = IoModeType.PAKOUT_BOOTING;
			TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
			if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
			&& !devpThread.getStation().get(inSta.getBackSta()).isLoading()
			&& devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
			// 出库模式
			devpThread.ioModeOf2F3 = IoModeType.PAKOUT_MODE;
			}
			}
			} else {
			// 入库模式
			devpThread.ioModeOf2F3 = IoModeType.PAKIN_MODE;
			}
			break;
			}
			}
			}
			} catch (Exception e) {
			e.printStackTrace();
			}
			apiLogService.save("堆垛机开始运行"
			,wmsUrl+"wcsManager/wcsInterface/taskStatusFeedback"
			,null
			,"127.0.0.1"
			,JSON.toJSONString(taskOverToWms)
			,response
			,true
			);
			return response;
			}

			private TaskWrk createTask(GetWmsDto dto, String barcode){
			String wcsLocNo = dto.getLocNo();
			if(Cools.isEmpty(wcsLocNo)){
			return null;

			/**
			* 跑库程序
			*/
			public void debug(String sts, Long modiUser, Integer loc_type1) {
			if (!enable) {
			return;
			}
			List<BasCrnp> basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>());
			if (basCrnps.isEmpty()) {
			return;
			}
			for (BasCrnp basCrnp : basCrnps) {
			if (!basCrnp.getInEnable().equals("N") \|\| !basCrnp.getOutEnable().equals("Y")) {
			continue;
			}
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", basCrnp.getCrnNo()).eq("io_type", 11));
			if (Cools.isEmpty(wrkMasts) \|\| wrkMasts.isEmpty()) {
			int i = locMastService.selectCount(new EntityWrapper<LocMast>().eq("loc_sts", sts).eq("loc_type1", loc_type1).ne("modi_user", modiUser));
			LocMast locMastStart = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_sts", sts).eq("loc_type1", loc_type1).ne("modi_user", modiUser));
			if (locMastStart == null \|\| i > 1) {
			continue;
			}
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
			.eq("loc_sts", "O")
			.eq("crn_no", basCrnp.getCrnNo())
			.eq("loc_type1", locMastStart.getLocType1())
			.ne("modi_user", 77));
			if (Cools.isEmpty(locMasts)) {
			continue;
			}
			Random random = new Random();
			LocMast locMastEnd = locMasts.get(random.nextInt(locMasts.size()));
			locMove(locMastStart, locMastEnd, Long.parseLong(basCrnp.getCrnNo().toString()));
			}
			}
			}


			public void locMove(LocMast sourceLoc, LocMast locNo, Long userId) {
			List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLoc.getLocNo()));
			LocMast loc = locMastService.selectById(locNo);
			if (!sourceLoc.getCrnNo().equals(loc.getCrnNo())) {
			throw new CoolException("移转库位属于不同堆垛机");
			}
			Date now = new Date();
			TaskWrk taskWrk = new TaskWrk();
			int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
			taskWrk.setTaskNo(dto.getWrkNo());//任务号
			taskWrk.setWrkNo(workNo1);
			taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
			taskWrk.setCreateTime(now);
			taskWrk.setIoType(1);//任务类型
			taskWrk.setIoPri(Cools.isEmpty(dto.getTaskPriority()) ? 300 : Integer.parseInt(dto.getTaskPriority()));//优先级
			taskWrk.setBarcode(barcode);//条码
			LocMast locMast = locMastService.selectByLocNo(wcsLocNo);
			taskWrk.setCrnNo(locMast.getCrnNo());
			taskWrk.setTargetPoint(wcsLocNo);
			taskWrk.setStartPoint(dto.getStaNo().toString());
			if(taskWrk.getIoType() == 1){
			taskWrk.setWrkSts(2);
			if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
			taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
			}

			// } else if (param.getIoType() == 2) {
			// taskWrk.setWrkSts(11);
			// if (!Cools.isEmpty(param.getStartPoint())) {
			// taskWrk.setStartPoint(Utils.getWcsLocNo(param.getStartPoint()));//起点
			// taskWrk.setOriginStartPoint(param.getStartPoint());
			// }
			// taskWrk.setTargetPoint(param.getTargetPoint());
			// }else if (param.getIoType() == 3){
			// taskWrk.setWrkSts(11);
			// if (!Cools.isEmpty(param.getStartPoint())) {
			// taskWrk.setStartPoint(param.getStartPoint());//起点
			// taskWrk.setOriginStartPoint(param.getStartPoint());
			// }
			// 获取工作号
			int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
			// 保存工作档
			WrkMast wrkMast = new WrkMast();
			wrkMast.setWrkNo(workNo);
			wrkMast.setIoTime(now);
			wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
			wrkMast.setIoType(11); // 入出库状态： 11.库格移载
			wrkMast.setIoPri(10D);
			wrkMast.setCrnNo(sourceLoc.getCrnNo());
			wrkMast.setSourceLocNo(sourceLoc.getLocNo()); // 源库位
			wrkMast.setLocNo(locNo.getLocNo()); // 目标库位
			wrkMast.setFullPlt(Cools.isEmpty(locDetls) ? "N" : "Y"); // 满板：Y
			wrkMast.setPicking("N"); // 拣料
			wrkMast.setExitMk("N"); // 退出
			wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
			wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
			wrkMast.setLinkMis("N");
			wrkMast.setAppeUser(userId);
			wrkMast.setAppeTime(now);
			wrkMast.setModiUser(userId);
			wrkMast.setModiTime(now);
			boolean res = wrkMastService.insert(wrkMast);
			if (!res) {
			throw new CoolException("保存工作档失败");
			}
			return taskWrk;
			// 工作档明细保存
			for (LocDetl locDetl : locDetls) {
			WrkDetl wrkDetl = new WrkDetl();
			wrkDetl.sync(locDetl);
			wrkDetl.setWrkNo(workNo);
			wrkDetl.setIoTime(now);
			wrkDetl.setAnfme(locDetl.getAnfme());
			wrkDetl.setAppeTime(now);
			wrkDetl.setAppeUser(userId);
			wrkDetl.setModiTime(now);
			wrkDetl.setModiUser(userId);
			if (!wrkDetlService.insert(wrkDetl)) {
			throw new CoolException("保存工作档明细失败");
			}
			}
			// 修改源库位状态
			if (sourceLoc.getLocSts().equals("D") \|\| sourceLoc.getLocSts().equals("F")) {
			sourceLoc.setLocSts("R"); // R.出库预约
			sourceLoc.setModiUser(userId);
			sourceLoc.setModiTime(now);
			if (!locMastService.updateById(sourceLoc)) {
			throw new CoolException("更新源库位状态失败");
			}
			} else {
			throw new CoolException("源库位出库失败，状态：" + sourceLoc.getLocSts$());
			}
			// 修改目标库位状态
			if (loc.getLocSts().equals("O")) {
			loc.setLocSts("S"); // S.入库预约
			loc.setModiTime(now);
			loc.setModiUser(userId);
			if (!locMastService.updateById(loc)) {
			throw new CoolException("更新目标库位状态失败");
			}
			} else {
			throw new CoolException("移转失败，目标库位状态：" + loc.getLocSts$());
			}
			}

			/**
			* 转移任务下发
			*/
			public void transferTaskStart() {
			for (DevpSlave.Sta sta : slaveProperties.getDevp().get(1).getInSta()) {
			try {
			// 获取入库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
			StaProtocol staProtocol = devpThread.getStation().get(sta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == 0)) {
			// 查询工作档
			TransferTask transferTask = transferTaskService.selectByStartPoint(sta.getStaNo());
			if (transferTask == null) {
			continue;
			}
			log.info("下发输送线转移任务：taskWrk:" + JSON.toJSONString(transferTask));
			staProtocol.setWorkNo(transferTask.getWrkNo().shortValue());
			staProtocol.setStaNo(transferTask.getTargetPoint().shortValue());
			boolean offer = false;
			try {
			offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
			} catch (Exception e) {
			log.error("下发输送线转移任务：异常:" + e);
			log.error("下发输送线转移任务：异常:offer:" + offer);
			}
			if (offer) {
			log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(transferTask));
			transferTask.setStatus(2);
			transferTaskService.updateById(transferTask);
			} else {
			log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(transferTask));
			}
			}
			} catch (Exception e) {
			log.error("转移任务异常:异常信息：" + e);
			}
			}

			}

			/**
			* 转移任务完成
			*/
			public void transferTaskEnd() {
			for (DevpSlave.Sta sta : slaveProperties.getDevp().get(1).getInSta()) {
			try {
			// 获取终点站
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
			StaProtocol staProtocol = devpThread.getStation().get(sta.getOverSta());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == 0)) {
			// 查询工作档
			TransferTask transferTask = transferTaskService.selectByEndPoint(sta.getStaNo());
			if (transferTask == null) {
			continue;
			}
			log.info("转移任务完成：transferTask:" + JSON.toJSONString(transferTask));
			transferTask.setStatus(3);
			transferTaskService.updateById(transferTask);
			}
			} catch (Exception e) {
			log.error("转移任务异常:异常信息：" + e);
			}
			}

			}

			}