package com.zy.asrs.service.impl; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.Wrapper; import com.core.common.*; import com.core.exception.CoolException; import com.zy.asrs.controller.TaskWrkController; import com.zy.asrs.domain.enums.LedErrorAreaType; import com.zy.asrs.domain.enums.TaskStatusType; import com.zy.asrs.entity.*; import com.zy.asrs.mapper.*; import com.zy.asrs.service.*; import com.zy.asrs.utils.*; import com.zy.common.model.LocTypeDto; import com.zy.common.model.SearchLocParam; import com.zy.common.model.StartupDto; 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.*; import com.zy.core.enums.*; import com.zy.core.model.*; import com.zy.core.model.command.CrnCommand; import com.zy.core.model.protocol.*; import com.zy.core.properties.SlaveProperties; import com.zy.core.thread.BarcodeThread; import com.zy.core.thread.RgvThread; import com.zy.core.thread.SiemensDevpThread; import com.zy.system.entity.license.LicenseVerify; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.interceptor.TransactionAspectSupport; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; /** * 立体仓库WCS系统主流程业务 * Created by vincent on 2020/8/6 */ @Slf4j @Service("mainService") @Transactional public class MainServiceImpl { public static final long COMMAND_TIMEOUT = 5 * 1000; @Autowired private CommonService commonService; @Autowired private SlaveProperties slaveProperties; @Autowired private WrkMastMapper wrkMastMapper; @Autowired private WrkDetlService wrkDetlService; @Autowired private LocMastService locMastService; @Autowired private BasCrnpService basCrnpService; @Autowired private BasDevpService basDevpService; @Autowired private LocDetlService locDetlService; @Autowired private WrkMastService wrkMastService; @Autowired private BasDevpPositionService basDevpPositionService; @Autowired private TaskWrkService taskWrkService; @Value("${wms.url}") private String wmsUrl; @Value("${inventory.number}") private Integer inventoryNumber; public Integer wrkNo = 10002; @Value("${wms.rgvOpen}") private boolean rgvOpen; @Value("${constant-parameters.trackEntireLength}") private Long trackEntireLength; @Value("${constant-parameters.trackBenchmark}") private Long trackBenchmark; @Value("${constant-parameters.trackProportion}") private Long trackProportion; @Value("${constant-parameters.avoidDistance}") private Long avoidDistance; @Autowired private TaskWrkLogServiceImpl taskWrkLogService; public Long currentTimeMilliConnectCrnAuto= 0L; /* * 验证许可证是否有效 * */ public synchronized boolean licenseVerify() { try{ // if (true) { // return true; // } return new LicenseVerify().verify(); } catch (Exception e){ log.info("许可证验证失败！！异常：{}",e.getMessage()); } return false; } /** * 组托 * 入库站，根据条码扫描生成入库工作档，工作状态 2 */ public synchronized void generateStoreWrkFile() { // 根据输送线plc遍历 for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历入库口 for (DevpSlave.Sta inSta : devp.getInSta()) { // 获取条码扫描仪信息 BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode()); if (barcodeThread == null) { continue; } String barcode = barcodeThread.getBarcode(); if (!Cools.isEmpty(barcode)) { // log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode); if ("00000000".endsWith(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || !CodeDetectionUtil.barcodeDetection(barcode)) { continue; } } else { continue; } // 获取入库站信息 // SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } // 尺寸检测异常 boolean back = false; String errMsg = "异常："; if (staProtocol.isFrontErr()) { errMsg = errMsg+"前超限；"; back = true; } if (staProtocol.isBackErr()) { errMsg = errMsg+"后超限"; back = true; } if (staProtocol.isHighErr()) { errMsg = errMsg+"高超限"; back = true; } if (staProtocol.isLeftErr()) { errMsg = errMsg+"左超限"; back = true; } if (staProtocol.isRightErr()) { errMsg = errMsg+"右超限"; back = true; } if (staProtocol.isWeightErr()) { errMsg = errMsg+"超重"; back = true; } if (staProtocol.isBarcodeErr()) { errMsg = errMsg+"扫码失败"; back = true; } // 退回 if (back) { // led 异常显示 LedErrorThreadUtil.ledErrorThread(errMsg,inSta.getLed(), LedErrorAreaType.FOUR_BARCODE.getDesc()); continue; } // 入出库模式判断 // if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; } // if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) { // continue; // } // 判断是否满足入库条件 if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && !staProtocol.isEmptyMk() && staProtocol.getWorkNo() == 0 && staProtocol.isPakMk()) {// && !Cools.isEmpty(barcode)) { // if(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode)) { // log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode); // //条码为空或者不符合，退库到172站点 // staProtocol.setWorkNo((short)32222); // staProtocol.setStaNo((short)172); // devpThread.setPakMk(staProtocol.getSiteId(), false); // boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); // if (!result) { // throw new CoolException("更新plc站点信息失败"); // } // continue; // } // 判断重复工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode); if (wrkMast != null) { // LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); barcodeThread.setBarcode(""); staProtocol.setWorkNo(wrkMast.getWrkNo()); staProtocol.setStaNo(wrkMast.getStaNo().shortValue()); devpThread.setPakMk(staProtocol.getSiteId(), false,238); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { LedErrorThreadUtil.ledErrorThread("更新plc站点信息失败!站点号："+inSta.getStaNo(),inSta.getLed(), LedErrorAreaType.ONE_OTHER.getDesc()); throw new CoolException("更新plc站点信息失败"); } return; } // // 获取入库通知档 // List waitPakins = waitPakinMapper.selectList(new EntityWrapper().eq("zpallet", barcode).eq("io_status", "N")); // if (waitPakins.isEmpty()) { // log.error("无此入库条码数据。条码号={}", barcode); // continue; // } try { LocTypeDto locTypeDto = new LocTypeDto(staProtocol); SearchLocParam param = new SearchLocParam(); param.setBarcode(barcode); param.setIoType(1); param.setSourceStaNo(inSta.getStaNo()); param.setLocType1(locTypeDto.getLocType1()); String response = new HttpHandler.Builder() .setUri(wmsUrl) .setPath("/rpc/pakin/loc/v1") .setJson(JSON.toJSONString(param)) .build() .doPost(); JSONObject jsonObject = JSON.parseObject(response); if (jsonObject.getInteger("code").equals(200)) { StartupDto dto = jsonObject.getObject("data", StartupDto.class); // LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); barcodeThread.setBarcode(""); staProtocol.setWorkNo(dto.getWorkNo()); // if(Cools.isEmpty(dto.getRgvNo()) || dto.getRgvNo() <= 0) { // staProtocol.setStaNo(607);//607 // } else {//如果存在RGV编号，说明需要RGV接驳，先下发任务到RGV源站 staProtocol.setStaNo(dto.getRgvSstaNo().shortValue()); // } devpThread.setPakMk(staProtocol.getSiteId(), false,283); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { LedErrorThreadUtil.ledErrorThread("更新plc站点信息失败!站点号："+inSta.getStaNo(),inSta.getLed(), LedErrorAreaType.ONE_OTHER.getDesc()); throw new CoolException("更新plc站点信息失败"); } } else { // led 异常显示 LedErrorThreadUtil.ledErrorThread("入库请求失败"+jsonObject.getInteger("code"),inSta.getLed(), LedErrorAreaType.ONE_OTHER.getDesc()); log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response); } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * 空栈板初始化入库,叉车入库站放货 */ public synchronized void storeEmptyPlt() { for (DevpSlave devp : slaveProperties.getDevp()) { // if (devp.getId()==1) continue; // 遍历空板入库口 for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) { // 获取空板入库站信息 SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); StaProtocol staProtocol = devpThread.getStation().get(emptyInSta.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } // 站点条件判断 if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isEmptyMk() && ((staProtocol.getWorkNo() > 9000 && staProtocol.getWorkNo() <= 9999) || staProtocol.getWorkNo()==0) && staProtocol.isPakMk()) { try { LocTypeDto locTypeDto = new LocTypeDto(staProtocol); SearchLocParam param = new SearchLocParam(); param.setIoType(10); param.setSourceStaNo(emptyInSta.getStaNo()); param.setLocType1(locTypeDto.getLocType1()); String response = new HttpHandler.Builder() .setUri(wmsUrl) .setPath("/rpc/pakin/loc/v1") .setJson(JSON.toJSONString(param)) .build() .doPost(); JSONObject jsonObject = JSON.parseObject(response); if (jsonObject.getInteger("code").equals(200)) { StartupDto dto = jsonObject.getObject("data", StartupDto.class); // 更新站点信息 且 下发plc命令 staProtocol.setWorkNo(dto.getWorkNo()); staProtocol.setStaNo(dto.getStaNo().shortValue()); devpThread.setPakMk(staProtocol.getSiteId(), false,4087); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { LedErrorThreadUtil.ledErrorThread("更新plc站点信息失败!站点号："+emptyInSta.getStaNo(),emptyInSta.getLed(), LedErrorAreaType.ONE_OTHER.getDesc()); throw new CoolException("更新plc站点信息失败"); } } else { log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response); } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * 拣料、并板、盘点再入库 */ public synchronized void stnToCrnStnPick() { for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历拣料入库口 for (DevpSlave.Sta pickSta : devp.getPickSta()) { // // 获取条码扫描仪信息 // BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode()); // if (barcodeThread == null) { // continue; // } // String barcode = barcodeThread.getBarcode(); // if(!Cools.isEmpty(barcode)) { // log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode); // if("NG".endsWith(barcode) || "NoRead".equals(barcode)) { // continue; // } // } else { // continue; // } // 获取拣料入库站信息 SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } // // 入出库模式判断 // if (devpThread.ioMode != IoModeType.PAKIN_MODE) { continue; } if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) { // WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode); WrkMast wrkMast = wrkMastMapper.selectPakInStep5(staProtocol.getSiteId(),"7"); if (wrkMast == null) { // 无拣料数据 continue; } if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo())) { continue; } // 获取库位号 try { SearchLocParam param = new SearchLocParam(); param.setBarcode(wrkMast.getBarcode()); param.setIoType(wrkMast.getIoType()); param.setSourceStaNo(pickSta.getStaNo()); //作业站点 param.setLocType1((short)1); String response = ""; log.info("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param); try { response = new HttpHandler.Builder() .setUri(wmsUrl) .setPath("/rpc/pakin2/loc/v1") .setJson(JSON.toJSONString(param)) .setTimeout(15, TimeUnit.SECONDS) .build() .doPost(); } catch(Exception e){ log.error("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param); log.error("stnToCrnStnPick2===>>盘点查库位入库接口失败", e); e.printStackTrace(); continue; } log.info("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param); log.info("入库作业站"+pickSta.getStaNo()+"下发盘点再入库任务请求WMS返回结果===>>" + response); if(response.equals("")) { continue; } JSONObject jsonObject = JSON.parseObject(response); // LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed()); Integer code = jsonObject.getInteger("code"); if (code == 200) { StartupDto dto = jsonObject.getObject("data", StartupDto.class); if (Cools.isEmpty(dto) || Cools.isEmpty(dto.getStaNo())) { log.error("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位失败===>>" + jsonObject.toJSONString()); } else { log.info("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位成功===>>" + jsonObject.toJSONString()); try { // 更新站点信息 且 下发plc命令 staProtocol.setWorkNo(wrkMast.getWrkNo()); staProtocol.setStaNo(dto.getStaNo().shortValue()); devpThread.setPakMk(staProtocol.getSiteId(), false,1096); // ledThread.errorReset(); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId()); } log.info("任务号"+wrkMast.getWrkNo()+"盘点/拣料再入库任务下发成功===>>" + staProtocol); } catch (Exception e) { log.error("盘点再入库失败===>>" + e); e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } else { log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin2/loc/v1", JSON.toJSONString(param), response); } } catch (Exception e) { log.error("stnToCrnStnPick2===>>fail", e); e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * 堆垛机站出库到出库站 */ public synchronized void crnStnToOutStn() { for (CrnSlave crnSlave : slaveProperties.getCrn()) { // 遍历堆垛机出库站 for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) { // 获取堆垛机出库站信息 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() == null)) { // 查询工作档 WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId()); if (wrkMast == null) { continue; } // 判断工作档条件 if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) { continue; } // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) { // 移动中 continue; } // 判断堆垛机状态等待确认 if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue()) && crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.forkPosType == CrnForkPosType.HOME) { // 命令下发区 -------------------------------------------------------------------------- // 下发站点信息 staProtocol.setWorkNo(wrkMast.getWrkNo()); staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo())); if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) { continue; } // 更新工作档状态为14失败 wrkMast.setWrkSts(14L); wrkMast.setCrnEndTime(new Date()); if (wrkMastMapper.updateById(wrkMast) != 0) { // 复位堆垛机 crnThread.setResetFlag(true); } else { log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } } } } } } /** * 入出库 ===>> 堆垛机入出库作业下发 */ public synchronized void crnIoExecute() { try{ for (CrnSlave crn : slaveProperties.getCrn()) { // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { continue; } BasCrnp basCrnp = basCrnpService.selectById(crn.getId()); if (basCrnp == null) { log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId()); continue; } // 只有当堆垛机空闲 并且 无任务时才继续执行 if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) { // 如果最近一次是入库模式 if (crnProtocol.getLastIo().equals("I")) { if (basCrnp.getInEnable().equals("Y")) { this.crnStnToLoc1(crn, crnProtocol); // 入库 crnProtocol.setLastIo("O"); } else if (basCrnp.getOutEnable().equals("Y")) { this.locToCrnStn1(crn, crnProtocol); // 出库 crnProtocol.setLastIo("I"); } } // 如果最近一次是出库模式 else if (crnProtocol.getLastIo().equals("O")) { if (basCrnp.getOutEnable().equals("Y")) { this.locToCrnStn1(crn, crnProtocol); // 出库 crnProtocol.setLastIo("I"); } else if (basCrnp.getInEnable().equals("Y")) { this.crnStnToLoc1(crn, crnProtocol); // 入库 crnProtocol.setLastIo("O"); } } } // 库位移转 this.locToLoc(crn, crnProtocol); // this.crnRebackHp(crnProtocol, crnThread); } }catch (Exception e){ log.error("堆垛机出入库下发报错"+e); } } /** * 库位移转 */ public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) { // 获取工作档信息 WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId()); if (null == wrkMast) { return; } // 获取源库位信息 LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo()); if (null == sourceSta) { log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo()); return; } // 源库位 库位状态判断 if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("S")) { return; } // 获取目标库位信息 LocMast sta = locMastService.selectById(wrkMast.getLocNo()); if (null == sta) { log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo()); return; } // 获取堆垛机信息 并 判断是否可入出 BasCrnp basCrnp = basCrnpService.selectById(slave.getId()); if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) { return; } // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { return; } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { return; } // 命令下发区 -------------------------------------------------------------------------- CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转 crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排 crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列 crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层 crnCommand.setDestinationPosX(sta.getRow1().shortValue()); // 目标库位排 crnCommand.setDestinationPosY(sta.getBay1().shortValue()); // 目标库位列 crnCommand.setDestinationPosZ(sta.getLev1().shortValue()); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand)); } else { // 修改工作档状态 11.生成出库ID => 12.吊车出库中 Date now = new Date(); wrkMast.setWrkSts(12L); wrkMast.setCrnStrTime(now); wrkMast.setModiTime(now); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo()); } } } /** * 入库 ===>> 堆垛机站到库位 * 2022-12-03 TQS修改，先遍历查询同台堆垛机工作档所有站点入库任务LIST，根据工作档任务排序优先级高于 根据堆垛机入库站点排序 */ public synchronized void crnStnToLoc1(CrnSlave slave, CrnProtocol crnProtocol) { List wrkMasts = wrkMastMapper.selectPakInStep12(slave.getId()); for(WrkMast wrkMast : wrkMasts){ if (wrkMast == null) { continue; } CrnSlave.CrnStn crnStn = null; for (CrnSlave.CrnStn crnStn1 : slave.getCrnInStn()){ if(crnStn1.getStaNo().equals(wrkMast.getStaNo())){ crnStn = crnStn1; break; } } if(Cools.isEmpty(crnStn)){ continue; } boolean flag = false; // 获取堆垛机入库站信息 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } // 查询站点详细信息 BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo()); if (staDetl == null) { log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo()); continue; } // if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable() // && staDetl.getCanining() != null && staDetl.getCanining().equals("Y") && staDetl.getWrkNo().equals(wrkMast.getWrkNo())) { // flag = true; // } if (staProtocol.isAutoing() && staProtocol.getWorkNo() > 0 && staDetl.getCanining() != null && staDetl.getCanining().equals("Y") && staDetl.getWrkNo().equals(wrkMast.getWrkNo())) { flag = true; } if (!flag) { continue; } // 获取库位信息 LocMast locMast = locMastService.selectById(wrkMast.getLocNo()); if (locMast == null) { log.error("查询库存无数据--库位号{}", wrkMast.getLocNo()); continue; } if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) { log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts()); continue; } // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { continue; } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { continue; } // 双深库位且浅库位有货，则需先对浅库位进行库位移转 if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) { String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo()); LocMast shallowLoc = locMastService.selectById(shallowLocNo); // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！ if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) { WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo); if (null == waitWrkMast) { log.error("{}库位异常，未检索到相应工作档！", shallowLocNo); } else { waitWrkMast.setIoPri(15D); waitWrkMast.setModiTime(new Date()); if (wrkMastMapper.updateById(waitWrkMast) == 0) { log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo()); } continue; } } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) { // 此标记避免多次执行移库任务 if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())) { // wrkMast.setUpdMk("Y"); // wrkMast.setIoPri(14D); // wrkMastMapper.updateById(wrkMast); // // 生成工作档,将浅库位移转到新的库位中 // moveLocForDeepLoc(slave, shallowLoc); if (moveLocForDeepLoc(slave, shallowLoc)){ wrkMast.setUpdMk("Y"); wrkMast.setIoPri(14D); wrkMastMapper.updateById(wrkMast); } // 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行) // moveLocForDeepLocPakin(slave, shallowLoc, wrkMast); } continue; } else if (shallowLoc.getLocSts().equals("Q")) { WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo); if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) { continue; } } } // 命令下发区 -------------------------------------------------------------------------- CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转 crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排 crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列 crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层 crnCommand.setDestinationPosX(locMast.getRow1().shortValue()); // 目标库位排 crnCommand.setDestinationPosY(locMast.getBay1().shortValue()); // 目标库位列 crnCommand.setDestinationPosZ(locMast.getLev1().shortValue()); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand)); } else { // 修改工作档状态 2.设备上走 => 3.吊车入库中 Date now = new Date(); wrkMast.setWrkSts(3L); wrkMast.setCrnStrTime(now); wrkMast.setModiTime(now); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo()); } } } } /** * 出库 ===>> 库位到堆垛机站 * 2022-12-03 TQS修改，先遍历查询工作档所有站点出库任务LIST，根据工作档任务排序优先级高于 根据堆垛机入库站点排序 */ public synchronized void locToCrnStn1(CrnSlave slave, CrnProtocol crnProtocol) { List wrkMasts = wrkMastMapper.selectPakOutStep12(slave.getId()); Double pri = 0.0; for (WrkMast wrkMast : wrkMasts) { if (wrkMast.getIoType() != 110){ if (wrkMast.getIoPri()>=pri){ pri = wrkMast.getIoPri(); } else { continue; } } if (wrkMast == null) { continue; } CrnSlave.CrnStn crnStn = null; for (CrnSlave.CrnStn crnStn1 : slave.getCrnOutStn()){ if(crnStn1.getStaNo().equals(wrkMast.getSourceStaNo())){ crnStn = crnStn1; break; } } if(Cools.isEmpty(crnStn)){ continue; } // 工作档状态判断 if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null) { log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType()); continue; } // 获取源库位信息 LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo()); if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("P")) { log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts()); continue; } // 获取堆垛机出库站信息 SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo()); if (staProtocol == null) { break; // continue; } else { staProtocol = staProtocol.clone(); } // // 入出库模式判断 // if (devpThread.ioMode != IoModeType.PAKOUT_MODE) { continue; } if (wrkMast.getStaNo() == 204 && devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) { continue; } // 查询站点详细信息 BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo()); if (staDetl == null) { log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo()); break; // continue; } // 判断堆垛机出库站状态 if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y") && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) { // 命令下发区 -------------------------------------------------------------------------- // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { // continue; break; } // 双深库位且浅库位有货，则需先对浅库位进行库位移转 if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) { String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo()); LocMast shallowLoc = locMastService.selectById(shallowLocNo); // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！ if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) { WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo); if (null == waitWrkMast) { log.error("{}库位异常，未检索到相应工作档！", shallowLocNo); } else { if (waitWrkMast.getWrkSts() == 11) { if (waitWrkMast.getIoPri() + 100000D < 999999999D) { waitWrkMast.setIoPri(waitWrkMast.getIoPri()+100000D); } else { waitWrkMast.setIoPri(999999999D); } waitWrkMast.setModiTime(new Date()); if (wrkMastMapper.updateById(waitWrkMast) == 0) { log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo()); } continue; } else { } } } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) { // WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo); //2022-08-16 modify,不根据updmk标记移库任务(容易被取消导致堵塞)，查询工作档是否存在任务 WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo); // 此标记避免多次执行移库任务 // if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk()) // || Cools.isEmpty(waitWrkMast)) { if (Cools.isEmpty(waitWrkMast)) { // wrkMast.setUpdMk("Y"); // wrkMastMapper.updateById(wrkMast); // // 生成工作档,将浅库位移转到新的库位中 // moveLocForDeepLoc(slave, shallowLoc); if (moveLocForDeepLoc(slave, shallowLoc)){ wrkMast.setUpdMk("Y"); // wrkMast.setIoPri(14D); wrkMastMapper.updateById(wrkMast); } } log.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo); continue; } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) { WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo); if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) { continue; } } else if (!shallowLoc.getLocSts().equals("O") ){ log.error("{}任务出库失败，浅库位堵塞！浅库位号:{},浅库位状态:{}", wrkMast.getWrkNo(), shallowLocNo,shallowLoc.getLocSts()); continue; } } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { break; // return; } // 1.堆垛机开始移动 CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转 crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排 crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列 crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层 crnCommand.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排 crnCommand.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列 crnCommand.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand)); } else { // 修改工作档状态 11.生成出库ID => 12.吊车出库中 Date now = new Date(); wrkMast.setWrkSts(12L); wrkMast.setCrnStrTime(now); wrkMast.setModiTime(now); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo()); } break; } } } } /** * 因双深库位阻塞，对浅库位进行移转（立即执行版) * tip：同步 */ private synchronized boolean moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc) { try { List rows = locMastService.queryDistinctRow(crn.getId()); LocMast loc = null; for (Integer row : rows) { if (Utils.isDeepLoc(slaveProperties, row)) { loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1()); if (loc != null) { if (Utils.isDeepLoc(slaveProperties, loc.getLocNo())) { String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo()); LocMast shallowLoc1 = locMastService.selectById(shallowLocNo); if (!shallowLoc1.getLocSts().equals("O")) { loc = null; } } } if (null != loc) { break; } } } if (null == loc) { for (Integer row : rows) { if (Utils.isShallowLoc(slaveProperties, row)) { loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1()); if (null != loc) {//对应深库位非在库状态,不能移库 String deepLoc = Utils.getDeepLoc(slaveProperties, loc.getLocNo()); LocMast deepLoc1 = locMastService.selectById(deepLoc); if (!deepLoc1.getLocSts().equals("F") && !deepLoc1.getLocSts().equals("D")) { loc = null; } } if (null != loc) { break; } } } } if (null == loc) { log.error("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo()); return false; // throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo()); } else { // 获取工作号 int workNo = commonService.getWorkNo(0); // 保存工作档 WrkMast wrkMast = new WrkMast(); wrkMast.setWrkNo(workNo); wrkMast.setIoTime(new Date()); wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID wrkMast.setIoType(11); // 入出库状态： 11.库格移载 wrkMast.setIoPri(13D); wrkMast.setCrnNo(crn.getId()); wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位 wrkMast.setLocNo(loc.getLocNo()); // 目标库位 wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板 wrkMast.setPicking("N"); // 拣料 wrkMast.setExitMk("N"); // 退出 wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板 wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码 wrkMast.setLinkMis("N"); wrkMast.setAppeTime(new Date()); wrkMast.setModiTime(new Date()); int res = wrkMastMapper.insert(wrkMast); if (res == 0) { log.error("双深库位 --- 浅库位阻塞异常！ ====>保存工作档失败"); return true; // throw new CoolException("保存工作档失败"); } // 工作档明细保存 if (shallowLoc.getLocSts().equals("F")) { List locDetls = locDetlService.selectList(new EntityWrapper().eq("loc_no", shallowLoc.getLocNo())); for (LocDetl locDetl : locDetls) { WrkDetl wrkDetl = new WrkDetl(); wrkDetl.setWrkNo(workNo); wrkDetl.setIoTime(new Date()); wrkDetl.setAnfme(locDetl.getAnfme()); VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制 wrkDetl.setAppeTime(new Date()); wrkDetl.setModiTime(new Date()); if (!wrkDetlService.insert(wrkDetl)) { log.error("双深库位 --- 浅库位阻塞异常！ ====>保存工作档明细失败"); return true; // throw new CoolException("保存工作档明细失败"); } } } // 修改源库位状态 if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) { shallowLoc.setLocSts("R"); // R.出库预约 shallowLoc.setModiTime(new Date()); if (!locMastService.updateById(shallowLoc)) { log.error("双深库位 --- 浅库位阻塞异常！ ====>更新源库位状态失败"); return true; // throw new CoolException("更新源库位状态失败"); } } else { log.error("双深库位 --- 浅库位阻塞异常！ ====>源库位出库失败"); return true; // throw new CoolException("源库位出库失败"); } // 修改目标库位状态 if (loc.getLocSts().equals("O")) { loc.setLocSts("S"); // S.入库预约 loc.setModiTime(new Date()); if (!locMastService.updateById(loc)) { log.error("双深库位 --- 浅库位阻塞异常！ ====>更新目标库位状态失败"); return true; // throw new CoolException("更新目标库位状态失败"); } } else { log.error("双深库位 --- 浅库位阻塞异常！ ====>移转失败"); return true; // throw new CoolException("移转失败"); } } } catch (Exception e) { log.error("双深库位阻塞，对浅库位进行移转失败", e); return true; // e.printStackTrace(); // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } return true; } /** * 执行对工作档的完成操作 */ public synchronized 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.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) { if (crnProtocol.getTaskNo() == 32222 || crnProtocol.getTaskNo() == 999) { // 堆垛机复位 crnThread.setResetFlag(true); } else { // 获取入库待确认工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue()); if (wrkMast == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo()); continue; } // 入库 + 库位转移 ==> 4.入库完成 if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) { wrkMast.setWrkSts(4L); } else { continue; } Date now = new Date(); wrkMast.setCrnEndTime(now); wrkMast.setModiTime(now); // 修改成功后复位堆垛机 if (wrkMastMapper.updateById(wrkMast) > 0) { // 堆垛机复位 crnThread.setResetFlag(true); } } } } } /** * 堆垛机5分钟无任务则回到源点 */ public void crnStnToOutStnSou() { for (CrnSlave crn : slaveProperties.getCrn()) { try{ // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { continue; } BasCrnp basCrnp = basCrnpService.selectById(crn.getId()); if (basCrnp == null) { log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId()); continue; } if (System.currentTimeMillis()-currentTimeMilliConnectCrnAuto<1000*60*10){ continue; } if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.statusType == CrnStatusType.IDLE && crnProtocol.getLoaded().equals((short)0) && crnProtocol.getCrnNo()!=0 && crnProtocol.getTaskNo() == 0 ) { if (crnProtocol.getBay()!=1 || crnProtocol.getLevel()!=1){ //获取工作档 List wrkMasts = wrkMastMapper.selectByCrnNo(crnProtocol.getCrnNo()); if (!wrkMasts.isEmpty()) { continue; } List WrkMastLogList = wrkMastMapper.selectByCrnNoLog(crnProtocol.getCrnNo()); if (!WrkMastLogList.isEmpty()) { boolean signT = false; for (WrkMast wrkMast : WrkMastLogList){ Date completeTime = wrkMast.getIoTime(); if (completeTime==null){ continue; } long differenceInSeconds = TimeCalculatorUtils.differenceInMilliseconds(completeTime, new Date()); if (differenceInSeconds <= 60*2*1000) { signT = true; break; } else { signT = false; break; } } if (signT){ continue; } } // 命令下发区 -------------------------------------------------------------------------- CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号 crnCommand.setTaskNo((short)999); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.GO_ORIGIN); // 任务模式: 站位移转4 Integer crnNo = crnProtocol.getCrnNo(); int row1 = crnNo * 4-1; if (crnNo>2){ row1 = row1-2; } crnCommand.setSourcePosX((short) row1); // 源库位排 crnCommand.setSourcePosY((short) 1); // 源库位列 crnCommand.setSourcePosZ((short) 1); // 源库位层 crnCommand.setDestinationPosX((short) row1); // 目标库位排 crnCommand.setDestinationPosY((short) 1); // 目标库位层 crnCommand.setDestinationPosZ((short) 1); // 目标库位列 if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) { log.error("堆垛机自动回源点失败，堆垛机号={}", crnProtocol.getCrnNo()); if (System.currentTimeMillis()-currentTimeMilliConnectCrnAuto>1000*60*10){ try{ DeviceErrorService deviceErrorService = SpringUtils.getBean(DeviceErrorService.class); deviceErrorService.addDeviceError("CrnErr", crnProtocol.getCrnNo(), "堆垛机自动回源点失败"); } catch (Exception e2){ } if (currentTimeMilliConnectCrnAuto == 0){ currentTimeMilliConnectCrnAuto = System.currentTimeMillis()-1000*60*10-1; } else { currentTimeMilliConnectCrnAuto = System.currentTimeMillis(); } } } } } } catch (Exception e){ log.error("堆垛机10分钟无任务则回到源点失败"); } } } /////////////////////////////////////RGV调度///////////////////////////////////// public synchronized void taskCreate() { for (RgvSlave rgvSlave : slaveProperties.getRgv()) { try { for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSta()) { WrkMast wrkMast = deviceDetectionCreate(inSta); if (!Cools.isEmpty(wrkMast)) { TaskWrk taskWrk = new TaskWrk(wrkMast); taskWrkService.insert(taskWrk); } } } catch (Exception e){ } } } public synchronized void taskCancel() { try { List taskList = new ArrayList<>(); for (RgvSlave rgvSlave : slaveProperties.getRgv()) { RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId()); TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache(); ConcurrentHashMap allTaskProtocol = taskProtocolCache.getAllTaskProtocol(); for (TaskProtocol taskProtocol : allTaskProtocol.values()){ taskList.add(taskProtocol.getTaskNo().toString()); } } Wrapper wrkWrapper = new EntityWrapper().eq("status", 5); for (String taskNo : taskList){ wrkWrapper.ne("task_no", taskNo); } int count = taskWrkService.selectCount(wrkWrapper); if (count>0){ taskWrkService.delete(wrkWrapper); } } catch (Exception e){ } } public synchronized void taskStart() { for (RgvSlave rgvSlave : slaveProperties.getRgv()) { try { if (rgvDetection(rgvSlave)) { String taskNoNow = rgvOtherTaskWrk(rgvSlave); List basDevpPositions = basDevpPositionService.selectList(new EntityWrapper().orderBy("plc_position", true)); boolean itSmall = new TrackRangeUtils().IsItSmall(rgvSlave); if (basDevpPositions.isEmpty()) { log.error("获取所有站点信息异常"); try{ DeviceErrorService deviceErrorService = SpringUtils.getBean(DeviceErrorService.class); deviceErrorService.addDeviceError("rgvErr", rgvSlave.getId(), "指令生成：获取所有站点信息异常"); } catch (Exception e2){ } continue; } List taskWrkList = new ArrayList<>(); List staList = new ArrayList<>(); for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSta()) { TaskWrk taskWrk = deviceDetection(inSta); if (taskWrk != null) { if (taskWrk.getWrkNo().toString().equals(taskNoNow)) continue; taskWrkList.add(taskWrk); staList.add(inSta.getStaNo()); } } if (taskWrkList.isEmpty() || staList.isEmpty()) continue; boolean sign = false; if (rgvOtherStatusEnable(rgvSlave)) { //分成上下两部分任务 List[] avoidRange = RouteRgvUtils.gradeRange(staList, basDevpPositions, itSmall); List rangeListSou = avoidRange[itSmall ? 0 : 1]; List rangeListSouOther = avoidRange[itSmall ? 1 : 0]; //就近排序 RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(rgvSlave.getId()); List rangeList = RouteRgvUtils.SortNearby(rangeListSou, rgvProtocol.RgvPos, basDevpPositions); List rangeListOther = RouteRgvUtils.SortNearby(rangeListSouOther, rgvProtocol.RgvPos, basDevpPositions); //所属部分就进取货 //筛选范围内任务 //就近排序 //筛选在范围任务 Long[][] avoidedRange = new TrackRangeUtils().avoidRangeArr(rgvSlave, trackEntireLength, trackBenchmark, avoidDistance); List belongToRange = RouteRgvUtils.SortNearby(RouteRgvUtils.belongToRange(rangeList, avoidedRange[0], basDevpPositions), rgvProtocol.RgvPos, basDevpPositions); if (!sign && staList.size()==1){ if (rgvOtherIDLEOther(rgvSlave)){ if (!rgvOtherIDLE(rgvSlave,staList.get(0))){ System.out.println("空闲就近跳过==="+rgvSlave.getId()+"==="); RgvErrCache.updateRgvErr(rgvSlave.getId(),staList.get(0)+"空闲就近跳过"); sign=true; } } if (sign){ for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staList.get(0))) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvSuper : rgvSlave.getRgvSuperSta()){ if (rgvSuper.getStaNo().equals(outStaNo)){ System.out.println("空闲就近跳过后因最远再次执行==="+rgvSlave.getId()+"==="); sign=false; break; } } } else { return; } break; } } } } if(!sign){ for (Integer staNoNow : belongToRange) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()))); if (RouteRgvUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) { System.out.println("全范围执行==="+rgvSlave.getId()+"==="+taskWrk); System.out.println("全范围执行==="+rgvSlave.getId()+"==="+JSON.toJSONString(belongToRange)); sign = taskGenerate(rgvSlave, rgvStn, 0); } } break; } } if (sign) { break; } } } if (!sign) { // 筛选范围内取货任务 for (Integer staNoNow : belongToRange) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvStnOut : rgvSlave.getRgvOutSta()) { if (rgvStnOut.getStaNo().equals(outStaNo)) { System.out.println("筛选范围内取货任务==="+rgvSlave.getId()+"==="+taskWrk); System.out.println("筛选范围内取货任务==="+rgvSlave.getId()+"==="+JSON.toJSONString(belongToRange)); sign = taskGenerate(rgvSlave, rgvStn, 0); break; } } } break; } } if (sign) { break; } } } if (!sign && staList.size()==1){ if (rgvOtherIDLEOther2(rgvSlave)){ if (!rgvOtherIDLE2(rgvSlave,staList.get(0))){ System.out.println("运行就近跳过==="+rgvSlave.getId()+"==="); RgvErrCache.updateRgvErr(rgvSlave.getId(),staList.get(0)+"运行就近跳过"); sign=true; } } if (sign){ for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staList.get(0))) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvSuper : rgvSlave.getRgvSuperSta()){ if (rgvSuper.getStaNo().equals(outStaNo)){ System.out.println("运行就近跳过后因最远再次执行==="+rgvSlave.getId()+"==="); sign=false; break; } } } else { return; } break; } } } } if (!sign && staList.size()>1) { for (Integer staNoNow : rangeList) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()))); if (RouteRgvUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) { System.out.println("筛选半边范围内任务==="+rgvSlave.getId()+"==="+taskWrk); System.out.println("筛选半边范围内任务==="+rgvSlave.getId()+"==="+JSON.toJSONString(belongToRange)); sign = taskGenerate(rgvSlave, rgvStn, 0); } } break; } } if (sign) { break; } } }else if (!sign && staList.size()==1){ BasDevpPosition basDevpPosition1 = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", staList.get(0))); if (Math.abs(basDevpPosition1.getPlcPosition()- rgvProtocol.getRgvPos())().eq("DEV_NO", BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()))); if (RouteRgvUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) { System.out.println("筛选半边范围内任务==="+rgvSlave.getId()+"==="+taskWrk); System.out.println("筛选半边范围内任务==="+rgvSlave.getId()+"==="+JSON.toJSONString(belongToRange)); sign = taskGenerate(rgvSlave, rgvStn, 0); } } break; } } if (sign) { break; } } } } if (!sign && staList.size()>1) { // 半边区域内取货任务 for (Integer staNoNow : rangeList) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvStnOut : rgvSlave.getRgvOutSta()) { if (rgvStnOut.getStaNo().equals(outStaNo)) { System.out.println("筛选半边范围取货任务==="+rgvSlave.getId()+"==="+taskWrk); System.out.println("筛选半边范围取货任务==="+rgvSlave.getId()+"==="+JSON.toJSONString(belongToRange)); sign = taskGenerate(rgvSlave, rgvStn, 0); break; } } } break; } } if (sign) { break; } } } if (!sign && staList.size()>1) { for (Integer staNoNow : rangeListOther) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvSuper : rgvSlave.getRgvSuperSta()){ if (rgvSuper.getStaNo().equals(outStaNo)){ System.out.println("因最远执行半边区域内放货任务==="+rgvSlave.getId()+"==="); BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()))); if (RouteRgvUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) { sign = taskGenerate(rgvSlave, rgvStn, 0); } break; } } } break; } if (sign) { break; } } if (sign) { break; } } }else if (!sign && staList.size()==1){ for (Integer staNoNow : rangeList) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvSuper : rgvSlave.getRgvSuperSta()){ if (rgvSuper.getStaNo().equals(outStaNo)){ System.out.println("因最远执行半边区域内放货任务==="+rgvSlave.getId()+"==="); BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()))); if (RouteRgvUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) { sign = taskGenerate(rgvSlave, rgvStn, 0); } break; } } } break; } if (sign) { break; } } if (sign) { break; } } } RgvErrCache.updateRgvErr(rgvSlave.getId(),"未查询到可执行任务"); } else { //可用区域就近取货 //就近排序 RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(rgvSlave.getId()); List rangeList = RouteRgvUtils.SortNearby(staList, rgvProtocol.RgvPos, basDevpPositions); // 半边区域内取货任务 for (Integer staNoNow : rangeList) { for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) { if (rgvStn.getStaNo().equals(staNoNow)) { TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk != null) { Integer outStaNo = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); for (RgvSlave.RgvStn rgvStnOut : rgvSlave.getRgvOutSta()) { if (rgvStnOut.getStaNo().equals(outStaNo)) { sign = taskGenerate(rgvSlave, rgvStn, 0); break; } } } break; } } if (sign) { break; } } } } } catch (Exception e) { log.error("任务生成失败===》异常信息：{}", e.getMessage()); try{ DeviceErrorService deviceErrorService = SpringUtils.getBean(DeviceErrorService.class); deviceErrorService.addDeviceError("rgvErr", rgvSlave.getId(), "指令生成失败"); } catch (Exception e2){ } } } } public String rgvOtherTaskWrk(RgvSlave slave) { RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, slave.getOtherId()); TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache(); ConcurrentHashMap allTaskProtocol = taskProtocolCache.getAllTaskProtocol(); if (!allTaskProtocol.isEmpty()) { for (TaskProtocol taskProtocol : allTaskProtocol.values()) { if (taskProtocol.getTaskNo() != 0) { return taskProtocol.getTaskNo().toString(); } } } return "无"; } public boolean rgvDetection(RgvSlave slave) { RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId()); RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getId()); if (rgvProtocol == null || rgvTaskProtocol == null) { return false; } if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1 || ((!rgvProtocol.getStatusType().equals(RgvStatusType.IDLE) || (Math.abs(rgvProtocol.getRgvPos() - rgvProtocol.getRgvPosDestination())>100)) && !rgvProtocol.getStatusType().equals(RgvStatusType.ROAM))) { return false; } if (rgvProtocol.getLoaded()==1){ return false; } RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId()); RgvTaskProtocol rgvTaskProtocolOther = RgvTaskCache.getRgvStatus(slave.getOtherId()); if (rgvProtocolOther == null) { return false; } if (rgvProtocolOther.statusEnable) { if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L) || rgvTaskProtocolOther.getAvoid() == -1 || rgvProtocolOther.getRgvPosDestination() == 0L) { return false; } } return true; } public boolean rgvOtherIDLEOther(RgvSlave slave) { RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getOtherId()); RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getOtherId()); if (rgvProtocol == null || rgvTaskProtocol == null) { return false; } if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1 || ((!rgvProtocol.getStatusType().equals(RgvStatusType.IDLE) || (Math.abs(rgvProtocol.getRgvPos() - rgvProtocol.getRgvPosDestination())>100)) && !rgvProtocol.getStatusType().equals(RgvStatusType.ROAM))) { return false; } if (rgvProtocol.getLoaded()!=0) { return false; } return true; } public boolean rgvOtherIDLEOther2(RgvSlave slave) { RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getOtherId()); RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getOtherId()); if (rgvProtocol == null || rgvTaskProtocol == null) { return false; } if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1) { return false; } if (rgvProtocol.getLoaded()!=0) { return false; } return true; } public boolean rgvOtherIDLE(RgvSlave slave,Integer staNo) { RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId()); RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getId()); if (rgvProtocol == null || rgvTaskProtocol == null) { return false; } if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1 || ((!rgvProtocol.getStatusType().equals(RgvStatusType.IDLE) || (Math.abs(rgvProtocol.getRgvPos() - rgvProtocol.getRgvPosDestination())>100)) && !rgvProtocol.getStatusType().equals(RgvStatusType.ROAM))) { return false; } RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId()); if (rgvProtocolOther == null) { return true; } if (rgvProtocolOther.statusEnable) { BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", staNo)); long abs = Math.abs(Math.abs(basDevpPosition.getPlcPosition() - rgvProtocol.getRgvPos()) - Math.abs(basDevpPosition.getPlcPosition() - rgvProtocolOther.getRgvPos())); if (abs<100){ return true; } if (Math.abs(basDevpPosition.getPlcPosition() - rgvProtocol.getRgvPos()) >= Math.abs(basDevpPosition.getPlcPosition() - rgvProtocolOther.getRgvPos())){ return false; } } return true; } public boolean rgvOtherIDLE2(RgvSlave slave,Integer staNo) { RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId()); RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getId()); if (rgvProtocol == null || rgvTaskProtocol == null) { return false; } if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1 || ((!rgvProtocol.getStatusType().equals(RgvStatusType.IDLE) || (Math.abs(rgvProtocol.getRgvPos() - rgvProtocol.getRgvPosDestination())>100)) && !rgvProtocol.getStatusType().equals(RgvStatusType.ROAM))) { return false; } RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId()); if (rgvProtocolOther == null) { return true; } if (rgvProtocolOther.statusEnable) { BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", staNo)); long abs = Math.abs(Math.abs(basDevpPosition.getPlcPosition() - rgvProtocol.getRgvPos()) - Math.abs(basDevpPosition.getPlcPosition() - rgvProtocolOther.getRgvPos())); if (abs<100){ return true; } if (Math.abs(basDevpPosition.getPlcPosition()-rgvProtocol.getRgvPos()) >= Math.abs(basDevpPosition.getPlcPosition()-rgvProtocolOther.getRgvPos())){ return false; } } return true; } public WrkMast deviceDetectionCreate(RgvSlave.RgvStn inSta) { DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, inSta.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo()); if (staProtocol == null) { return null; } // 判断是否满足取货条件 if (staProtocol.isAutoing() // && staProtocol.isLoading() // && staProtocol.isStaOk() && staProtocol.getWorkNo() != 0) { WrkMast wrkMast = wrkMastService.selectByWrkNo(staProtocol.getWorkNo()); if (!Cools.isEmpty(wrkMast)){ if (inSta.getStaNo()==117 || inSta.getStaNo()==120 || inSta.getStaNo()==123 || inSta.getStaNo()==217 || inSta.getStaNo()==220 || inSta.getStaNo()==223){ if (wrkMast.getIoType()>100){ return null; } } TaskWrk taskWrk = taskWrkService.selectByTaskNo(staProtocol.getWorkNo()); if (Cools.isEmpty(taskWrk)){ return wrkMast; } } } return null; } public TaskWrk deviceDetection(RgvSlave.RgvStn inSta) { DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, inSta.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo()); if (staProtocol == null) { return null; } // 判断是否满足取货条件 if (!staProtocol.isPakMkTask()) { devpThread.setErrorDev(staProtocol.getSiteId(), "任务已下发等待小车取"); return null; } // 判断是否满足取货条件 if (staProtocol.isAutoing() // && staProtocol.isLoading() // && staProtocol.isStaOk() && staProtocol.getWorkNo() != 0) { TaskWrk taskWrk = taskWrkService.selectByTaskNo(staProtocol.getWorkNo()); if (taskWrk != null) { Integer stano = staProtocol.getStaNo().intValue(); if (staProtocol.getSiteId() == 1004 || staProtocol.getSiteId()==1020){ if (!staProtocol.isPakMkRun()) { devpThread.setErrorDev(staProtocol.getSiteId(), "异常回退标记，需要回退"); return null; } if (!staProtocol.isLoading()) { devpThread.setErrorDev(staProtocol.getSiteId(), "无物"); return null; } if (!staProtocol.isInEnable()) { devpThread.setErrorDev(staProtocol.getSiteId(), "等待可入信号"); return null; } // if (!staProtocol.isStaOk()) { // devpThread.setErrorDev(staProtocol.getSiteId(), "等待链条就绪"); // return null; // } // 尺寸检测异常 boolean back = false; String errMsg = "-"; if (staProtocol.getGrossWt()>=600){ errMsg = "超重："+staProtocol.getGrossWt()+"kg"; back = true; } if (staProtocol.isFrontErr()) { if (!back){ errMsg = "前超限"; } else { errMsg = errMsg+"---"+"前超限"; } back = true; } if (staProtocol.isBackErr()) { if (!back){ errMsg = "后超限"; } else { errMsg = errMsg+"---"+"后超限"; } back = true; } if (staProtocol.isHighErr()) { if (!back){ errMsg = "高超限"; } else { errMsg = errMsg+"---"+"高超限"; } back = true; } if (staProtocol.isLeftErr()) { if (!back){ errMsg = "左超限"; } else { errMsg = errMsg+"---"+"左超限"; } back = true; } if (staProtocol.isRightErr()) { if (!back){ errMsg = "右超限"; } else { errMsg = errMsg+"---"+"右超限"; } back = true; } // if (!back && staProtocol.isWeightErr()) { // errMsg = "超重"; // back = true; // } if (staProtocol.isBarcodeErr()) { if (!back){ errMsg = "扫码失败"; } else { errMsg = errMsg+"---"+"扫码失败"; } back = true; } // 退回 if (back) { if (stano.equals(staProtocol.getStaNo() + 1)) { return null; } if (!staProtocol.isPakMk()) { return null; } System.out.println("扫码入库失败，{"+inSta.getStaNo()+"}入库站因{"+errMsg+"}异常，托盘已被退回"); // News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg); staProtocol.setWorkNo(9999); int staNoInt = staProtocol.getStaNo() + 1; staProtocol.setStaNo((short)staNoInt); devpThread.setPakMk(staProtocol.getSiteId(), false,1899); devpThread.setPakMkRun(staProtocol.getSiteId(), false); devpThread.setPakMkTask(staProtocol.getSiteId(), false); devpThread.setErrorDev(staProtocol.getSiteId(), errMsg); MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol)); try{ taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示 taskWrk.setModiTime(new Date()); taskWrkService.updateById(taskWrk); } catch (Exception e){ devpThread.setErrorDev(staProtocol.getSiteId(), errMsg+"异常信息保存工作档案失败！"); } return null; } } return taskWrk; } } else if (staProtocol.isAutoing() && staProtocol.getWorkNo() == 0 && !staProtocol.isLoading()){ if (inSta.isDirectionOther()){ StaProtocol staProtocolOther = devpThread.getStation().get(inSta.getStaNoOther()); if (staProtocolOther == null) { return null; } // 判断是否满足取货条件 if (staProtocolOther.isAutoing() && staProtocolOther.getWorkNo() != 0) { TaskWrk taskWrkOther = taskWrkService.selectByTaskNo(staProtocolOther.getWorkNo()); if (taskWrkOther != null) { return taskWrkOther; } } } } return null; } public boolean deviceDetection(RgvSlave.RgvStn inSta,Integer rgvNo) { ArrayList arrayList = new ArrayList() {{ add(1009); add(1011); add(1012); add(1014); add(1016); }}; try{ DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, inSta.getDevpPlcId()); ArrayList listW = new ArrayList(); ArrayList listL = new ArrayList(); for (Integer staNo : arrayList){ StaProtocol staProtocol = devpThread.getStation().get(staNo); if (staProtocol == null) { RgvErrCache.updateRgvErr(rgvNo,staNo+"站点数据丢失"); return false; } // 判断是否满足取货条件 if (staProtocol.getWorkNo() != 0) { if (!listW.contains(staProtocol.getWorkNo())) { listW.add(staProtocol.getWorkNo()); } } // 判断是否满足取货条件 if (staProtocol.isLoading()) { if (!listL.contains(staProtocol.getStaNo().intValue())) { listL.add(staProtocol.getStaNo().intValue()); } } } if (listW.size()>=3){ RgvErrCache.updateRgvErr(rgvNo,"等待1012拣选，防止堵塞"); return false; } if (listL.size()>=3){ RgvErrCache.updateRgvErr(rgvNo,"等待1012拣选，防止堵塞"); return false; } } catch (Exception e){ RgvErrCache.updateRgvErr(rgvNo,"1012检测异常："+e.getMessage()); return false; } return true; } public boolean rgvOtherStatusEnable(RgvSlave slave) { RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId()); if (rgvProtocolOther == null) { return true; } if (rgvProtocolOther.statusEnable) { // if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L)) { return true; // } } return false; } public boolean taskGenerate(RgvSlave rgvSlave, RgvSlave.RgvStn rgvStn, Integer sign) { try { RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId()); TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache(); DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId()); TaskProtocol issuedTake = new TaskProtocol(); TaskProtocol issuedPut = new TaskProtocol(); try { ConcurrentHashMap allTaskProtocol = taskProtocolCache.getAllTaskProtocol(); if (allTaskProtocol.size() > 0) { return false; } TaskWrk taskWrk = deviceDetection(rgvStn); if (taskWrk == null) { return false; } // Integer targetPointConvert = taskWrk.getTargetPointConvert(); Integer targetPointConvert = BarcodeUtils.getOutStaNo(taskWrk.getOriginTargetPoint()); if (targetPointConvert == null) { return false; } if (targetPointConvert == 1009){ if (!deviceDetection(rgvStn, rgvSlave.getId())){ return false; } } try{ devpThread.setPakMkTask(rgvStn.getStaNo(), false); } catch (Exception e2){ RgvErrCache.updateRgvErr(rgvSlave.getId(),rgvStn.getStaNo()+"小车任务下发标记更新失败"); } BasDevpPosition basDevpPositionSou = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", rgvStn.getStaNo())); BasDevpPosition basDevpPositionEnd = basDevpPositionService.selectOne(new EntityWrapper().eq("DEV_NO", targetPointConvert)); //执行 issuedTake.setTaskNo(Long.valueOf(taskWrk.getWrkNo())); issuedTake.setTaskStatus(2); issuedTake.setTargetPositionStaNo(basDevpPositionSou.getDevNo()); issuedTake.setTargetPositionStaNoEnd(basDevpPositionSou.getDevNo$()); issuedTake.setTargetPositionStaNoPlcId(basDevpPositionSou.getPlcId()); issuedTake.setTaskNoDirection(issuedTake.gettaskNoDirection$(issuedTake.getTaskNo(), issuedTake.getTaskStatus())); issuedTake.setTargetPosition(basDevpPositionSou.getPlcPosition()); issuedTake.setIsRunning(1); issuedTake.setDirection(basDevpPositionSou.getRgvSign()==1); issuedPut.setTaskNo(Long.valueOf(taskWrk.getWrkNo())); issuedPut.setTaskStatus(3); issuedPut.setTargetPositionStaNo(basDevpPositionEnd.getDevNo()); issuedPut.setTargetPositionStaNoEnd(basDevpPositionEnd.getDevNo$()); issuedPut.setTargetPositionStaNoPlcId(basDevpPositionEnd.getPlcId()); issuedPut.setTaskNoDirection(issuedPut.gettaskNoDirection$(issuedPut.getTaskNo(), issuedPut.getTaskStatus())); issuedPut.setTargetPosition(basDevpPositionEnd.getPlcPosition()); issuedPut.setIsRunning(1); issuedPut.setDirection(basDevpPositionEnd.getRgvSign()==1); try{ Date now = new Date(); taskWrk.setStatus(TaskStatusType.OVER.id); taskWrk.setModiTime(now);//更新时间 taskWrk.setCompleteTime(now);//完结时间 taskWrkService.updateById(taskWrk); } catch (Exception e){ } } catch (Exception e) { log.error("任务生成失败issued1===》异常信息：{}", e.getMessage()); RgvErrCache.updateRgvErr(rgvSlave.getId(),rgvStn.getStaNo()+"站点任务生成失败issued1"); try{ DeviceErrorService deviceErrorService = SpringUtils.getBean(DeviceErrorService.class); deviceErrorService.addDeviceError("rgvErr", rgvSlave.getId(), "任务生成失败issued1"); } catch (Exception e2){ } return false; } switch (sign) { case 1: taskProtocolCache.updateTaskProtocol(issuedTake); break; case 2: taskProtocolCache.updateTaskProtocol(issuedPut); break; default: taskProtocolCache.updateTaskProtocol(issuedTake); taskProtocolCache.updateTaskProtocol(issuedPut); break; } } catch (Exception e) { log.error("任务生成失败issued2===》异常信息：{}", e.getMessage()); RgvErrCache.updateRgvErr(rgvSlave.getId(),rgvStn.getStaNo()+"站点任务生成失败issued2"); try{ DeviceErrorService deviceErrorService = SpringUtils.getBean(DeviceErrorService.class); deviceErrorService.addDeviceError("rgvErr", rgvSlave.getId(), "站点任务生成失败issued2"); } catch (Exception e2){ } } return true; } }