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.Cools; import com.core.common.DateUtils; import com.core.common.R; import com.core.exception.CoolException; import com.zy.asrs.domain.enums.WorkNoType; 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.MatDto; import com.zy.common.model.SearchLocParam; import com.zy.common.model.StartupDto; import com.zy.common.service.CommonService; import com.zy.common.utils.CollectionUtils; import com.zy.common.utils.HttpHandler; import com.zy.common.utils.RedisUtil; import com.zy.common.utils.RgvUtils; import com.zy.core.CrnThread; import com.zy.core.DevpThread; import com.zy.core.Slave; import com.zy.core.cache.MessageQueue; import com.zy.core.cache.SlaveConnection; import com.zy.core.enums.*; import com.zy.core.model.*; import com.zy.core.model.command.*; import com.zy.core.model.cpmmandParam.CrnCommandParam; import com.zy.core.model.protocol.*; import com.zy.core.properties.SlaveProperties; import com.zy.core.thread.*; 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 springfox.documentation.spring.web.json.Json; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; /** * 立体仓库WCS系统主流程业务 * Created by vincent on 2020/8/6 */ @Slf4j @Service("mainService") @Transactional public class MainServiceImpl { public static final long COMMAND_TIMEOUT = 5 * 1000; // private static final int[][] execute = new int[][]{{1,4},{2,4},{3,4},{4,4},{5,6},{6,6},{7,4},{8,4},{9,3},{10,4},{11,4}}; private static final int[][] execute = new int[][]{{1,4},{2,4},{3,4},{4,4},{5,6},{6,6},{7,4},{8,4},{9,3},{10,4},{11,4}}; private static final Integer jarMaxLoc = 7; private static final Float jarTemperature = 80F; @Autowired private CommonService commonService; @Autowired private SlaveProperties slaveProperties; @Autowired private WrkMastMapper wrkMastMapper; @Autowired private WrkDetlService wrkDetlService; @Autowired private WaitPakinMapper waitPakinMapper; @Autowired private LocMastService locMastService; @Autowired private StaDescService staDescService; @Autowired private BasCrnpService basCrnpService; @Autowired private BasRgvService basRgvService; @Autowired private BasDevpService basDevpService; @Autowired private LocDetlService locDetlService; @Autowired private BasErrLogService basErrLogService; @Autowired private BasCrnErrorMapper basCrnErrorMapper; @Autowired private BasRgvErrMapper basRgvErrMapper; @Autowired private BasRgvErrLogService basRgvErrLogService; @Autowired private BasRgvPathService basRgvPathService; @Autowired private RedisUtil redisUtil; @Autowired private WrkMastStaMapper wrkMastStaMapper; @Autowired private BasRgvMapMapper basRgvMapMapper; @Autowired private RgvOneSignMapper rgvOneSignMapper; @Autowired private WrkMastCrnMapper wrkMastCrnMapper; @Autowired private WrkMastSplitTwinMapper wrkMastSplitTwinMapper; @Autowired private WrkMastSplitTwinService wrkMastSplitTwinService; @Autowired private BasJarMastService basJarMastService; @Autowired private WrkMastExecuteService wrkMastExecuteService; @Autowired private BasJarService basJarService; @Autowired private BasJarMapper basJarMapper; @Value("${wms.url}") private String wmsUrl; /** * 组托 * 入库站，根据条码扫描生成入库工作档，工作状态 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 ("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 异常显示 LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); if (ledThread != null) { MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errMsg)); } 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()); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { 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()); } devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { 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(); } } } } } /** * 组托 * 入库站，根据条码扫描生成入库工作档，工作状态 2 */ public synchronized void generateStoreWrkFileSingle() { // 根据输送线plc遍历 for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历入库口 for (DevpSlave.Sta inSta : devp.getInSingleSta()) { // 获取条码扫描仪信息 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 ("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 异常显示 LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); if (ledThread != null) { MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errMsg)); } 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) || !CodeDetectionUtil.barcodeDetection(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 wrkMast111 = wrkMastMapper.selectPakInStep111(inSta.getStaNo(), barcode); if (wrkMast111 != null) { LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); barcodeThread.setBarcode(""); staProtocol.setWorkNo(wrkMast111.getWrkNo()); staProtocol.setStaNo(wrkMast111.getStaNo()); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { throw new CoolException("更新plc站点信息失败"); } return; } // 判断重复工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode); if (wrkMast != null) { log.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo()); continue; } // // 获取入库通知档 // 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/pair/station/single/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(dto.getStaNo()); } else {//如果存在RGV编号，说明需要RGV接驳，先下发任务到RGV源站 staProtocol.setStaNo(dto.getRgvSstaNo()); } devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { throw new CoolException("更新plc站点信息失败"); } } else { log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/pair/station/single/loc/v1", JSON.toJSONString(param), response); } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * 组托 * 入库站，根据条码扫描生成入库工作档，工作状态 2 */ public synchronized void generateStoreWrkFileLarge() { // 根据输送线plc遍历 for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历入库口 for (DevpSlave.Sta inSta : devp.getInLargeSta()) { // 获取条码扫描仪信息 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 ("NG".endsWith(barcode) || "NoRead".equals(barcode) || !CodeDetectionUtil.barcodeDetection(barcode)) { continue; } if ("00000000".equals(barcode)){ log.error(inSta+"站点，扫码失败，barcode："+barcode); // led 异常显示 // LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); // if (ledThread != null) { // MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, inSta+"站点，扫码失败，barcode："+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 异常显示 LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); if (ledThread != null) { MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errMsg)); } 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) || !CodeDetectionUtil.barcodeDetection(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) { // log.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo()); // 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()); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { 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); barcodeThread.setBarcode(""); staProtocol.setWorkNo(dto.getWorkNo()); if(Cools.isEmpty(dto.getRgvNo()) || dto.getRgvNo() <= 0) { staProtocol.setStaNo(dto.getStaNo()); } else {//如果存在RGV编号，说明需要RGV接驳，先下发任务到RGV源站 staProtocol.setStaNo(dto.getRgvSstaNo()); } devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { throw new CoolException("更新plc站点信息失败"); } } else { SearchLocParam param2 = new SearchLocParam(); param2.setBarcode(barcode); param2.setSourceStaNo(inSta.getStaNo()); param2.setLocType1(locTypeDto.getLocType1()); String response2 = new HttpHandler.Builder() .setUri(wmsUrl) .setPath("/rpc/pakin/yx/loc/v33") .setJson(JSON.toJSONString(param2)) .build() .doPost(); JSONObject jsonObject2 = JSON.parseObject(response2); if (jsonObject2.getInteger("code").equals(200)) { log.info("大料箱自动组托成功！！"); } else { log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response); LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed()); if (ledThread != null) { MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, "入库失败！")); } } } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * wms入库 * 入库站，根据条码扫描生成入库工作档，工作状态 1 ==>> 2 */ public synchronized void generateStoreWrkFile0() { // 根据输送线plc遍历 for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历入库口 for (DevpSlave.Sta inSta : devp.getInWmsSta()) { // 获取入库站信息 SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } // // 入出库模式判断 // if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { // continue; // } // 判断是否满足入库条件 if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && !staProtocol.isEmptyMk() && staProtocol.getWorkNo() == 0 && staProtocol.isPakMk()) { // 判断重复工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep11(inSta.getStaNo()); if (wrkMast == null) { continue; } // 命令下发区 -------------------------------------------------------------------------- // 更新站点信息 且 下发plc命令 staProtocol.setWorkNo(wrkMast.getWrkNo()); Integer staNo = wrkMast.getStaNo(); if (wrkMast.getSourceStaNo()==145){ staNo = 147; } staProtocol.setStaNo(staNo); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (result) { // 更新工作主档 wrkMast.setWrkSts(2L); // 工作状态：2.设备上走 wrkMast.setModiTime(new Date()); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo()); } } else { log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId()); } } } } } /** * 拣料、并板、盘点再入库 */ 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()); devpThread.setPakMk(staProtocol.getSiteId(), false); // 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 stnToCrnStnPick2() { for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历拣料入库口 for (DevpSlave.Sta pickSta : devp.getPickSta2()) { // 获取拣料入库站信息 SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } BasDevp basDevp = basDevpService.selectById(staProtocol.getSiteId()); if (Cools.isEmpty(basDevp) || basDevp.getReportSign()!=1){ continue; } if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isPakMk() && staProtocol.getWorkNo()==0 && !staProtocol.isOutEnable() && staProtocol.isInEnable()) { WrkMast wrkMast = wrkMastMapper.selectPakInStep4(staProtocol.getSiteId(),"3"); if (wrkMast == null) { continue; } if (staProtocol.isEmptyMk()){ log.error("站点号"+staProtocol.getSiteId()+"空板信号异常！"); continue; } if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo())) { continue; } String barcode = wrkMast.getBarcode(); if(!Cools.isEmpty(barcode)) { if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) { continue; } } else { continue; } // 获取库位号 try { SearchLocParam param = new SearchLocParam(); param.setBarcode(barcode); 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()); devpThread.setPakMk(staProtocol.getSiteId(), false); // 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(); } // // 获取目标站 // Wrapper wrapper = new EntityWrapper() // .eq("type_no", wrkMast.getIoType() - 50) // .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站 // .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号 // StaDesc staDesc = staDescService.selectOne(wrapper); // if (Cools.isEmpty(staDesc)) { // log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo()); // continue; // } // // try { // // 保存工作明细档历史档 // if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) { // throw new CoolException("保存工作明细档历史档失败"); // } // // 保存工作主档历史档 // if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) { // throw new CoolException("保存工作主档历史档失败"); // } // // Date now = new Date(); // // 堆垛机站点(目标站) // Integer staNo = staDesc.getCrnStn(); // // 更新工作档数据状态 // wrkMast.setIoTime(now); // wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57 // wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走 // wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站 // wrkMast.setStaNo(staNo); // 目标站 // wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位 // wrkMast.setSourceLocNo(""); // 源库位清空 // wrkMast.setModiTime(now); // if (wrkMastMapper.updateById(wrkMast) == 0) { // throw new CoolException("更新工作档数据状态失败"); // } // // 更新明细档io_time (历史档关联使用） // wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now); // // 修改库位状态 Q.拣料/盘点/并板再入库 // LocMast locMast = locMastService.selectById(wrkMast.getLocNo()); // locMast.setLocSts("Q"); // locMast.setModiTime(new Date()); // if (!locMastService.updateById(locMast)) { // throw new CoolException("修改库位状态失败"); // } // } catch (Exception e) { // e.printStackTrace(); // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); // continue; // } // // // 更新站点信息 且 下发plc命令 // staProtocol.setWorkNo(wrkMast.getWrkNo()); // staProtocol.setStaNo(wrkMast.getStaNo()); // devpThread.setPakMk(staProtocol.getSiteId(), false); // boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); // if (!result) { // log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId()); // } } } } } /** * 拣料、并板、盘点再入库 拆垛位置 */ public synchronized void storeEmptyPlt4() { for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历叠盘入库口 for (DevpSlave.Sta pickSta : devp.getEmptyInSta2()) { // 获取入库站信息 SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId()); StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } BasDevp basDevp = basDevpService.selectById(staProtocol.getSiteId()); if (Cools.isEmpty(basDevp) || basDevp.getReportSign()!=1){ continue; } if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isPakMk() && staProtocol.getWorkNo()==0 && !staProtocol.isOutEnable() && staProtocol.isInEnable()) { WrkMast wrkMast = wrkMastMapper.selectPakInStep4(staProtocol.getSiteId(),"3"); if (wrkMast == null) { WrkMast wrkMast1 = wrkMastMapper.selectPakInStep5(staProtocol.getSiteId(),"3"); if (Cools.isEmpty(wrkMast1) && staProtocol.isEmptyMk()){ WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(staProtocol.getSiteId() + 19999L); if (Cools.isEmpty(wrkMastSta)){ WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),staProtocol.getSiteId()); wrkMastSta1.setType(2); wrkMastSta1.setWrkType(1); wrkMastStaMapper.insert(wrkMastSta1); } } } } } } } /** * 堆垛机站出库到出库站 */ public synchronized void crnStnToOutStn() { for (CrnSlave crnSlave : slaveProperties.getCrn()) { // 遍历堆垛机出库站 for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) { switch (crnSlave.getId()){ case 1: case 2: crnStnToOutStnOne(crnStn); continue; case 3: case 4: case 5: crnStnToOutStnTwo(crnSlave.getId(),crnStn,1); continue; case 6: case 7: crnStnToOutStnThree(crnStn); continue; default: break; } } } } /** * 堆垛机站出库到出库站 */ public synchronized boolean crnStnToOutStnOne(CrnSlave.CrnStn crnStn ) { try{ // 获取堆垛机出库站信息 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo()); if (staProtocol == null) { return false; } else { staProtocol = staProtocol.clone(); } if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) { // 查询工作档 WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId()); if (wrkMast == null) { return false; } // 判断工作档条件 if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) { return false; } // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) { // 移动中 return false; } WrkMastCrn wrkMastCrn = wrkMastCrnMapper.selectWrkNoOneAndTwo(crnProtocol.getTaskNo().intValue()); if (!Cools.isEmpty(wrkMastCrn) && wrkMastCrn.getWrkSts().equals(12L)){ wrkMast = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNo().intValue()); } else { return false; } // 判断堆垛机状态等待确认 if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue()) && crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.forkPosType == CrnForkPosType.HOME) { // 命令下发区 -------------------------------------------------------------------------- StaProtocol staProtocolOther = devpThread.getStation().get(crnStn.getStaNoOther()); if (staProtocolOther == null) { return false; } else { staProtocolOther = staProtocolOther.clone(); } if (staProtocolOther.isAutoing() && staProtocolOther.isLoading() && (staProtocolOther.getWorkNo() == 0 || staProtocolOther.getStaNo() == null)) { // WrkMastCrn wrkMastCrn = wrkMastCrnMapper.selectWrkNoOneAndTwo(wrkMast.getWrkNo()); WrkMast wrkMastOne = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNoOne().intValue()); WrkMast wrkMastTwo = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNoTwo().intValue()); WrkMast wrkMast1 = null; WrkMast wrkMast2 = null; if (Utils.getRow(wrkMastOne.getSourceLocNo()) == wrkMast.getCrnNo()*4){ wrkMast1 = wrkMastTwo; wrkMast2 = wrkMastOne; }else { wrkMast2 = wrkMastTwo; wrkMast1 = wrkMastOne; } // 下发站点信息 staProtocolOther.setWorkNo(Cools.isEmpty(wrkMast1.getWorkNoOther())? wrkMast1.getWrkNo():wrkMast1.getWorkNoOther()); staProtocolOther.setStaNo(wrkMast1.getStaNo()); if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocolOther))) { return false; } // 下发站点信息 staProtocol.setWorkNo(Cools.isEmpty(wrkMast2.getWorkNoOther())? wrkMast2.getWrkNo():wrkMast2.getWorkNoOther()); // staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo())); staProtocol.setStaNo(wrkMast2.getStaNo()); if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) { return false; } boolean sign = true; // 更新工作档状态为14失败 wrkMastCrn.setWrkSts(14L); if (wrkMastCrnMapper.updateById(wrkMastCrn) != 0) { } else { sign = false; log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } // 更新工作档状态为14失败 wrkMastOne.setWrkSts(14L); wrkMastOne.setCrnEndTime(new Date()); if (wrkMastMapper.updateById(wrkMastOne) != 0) { } else { sign = false; log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } // 更新工作档状态为14失败 wrkMastTwo.setWrkSts(14L); wrkMastTwo.setCrnEndTime(new Date()); if (wrkMastMapper.updateById(wrkMastTwo) != 0) { } else { sign = false; log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } if (sign){ // 复位堆垛机 crnThread.setResetFlag(true); return true; } } } } }catch (Exception e){ log.error("更新工作档的工作状态为14失败！！！ [出库站:{}]", crnStn.getStaNo()); } return false; } public synchronized boolean crnStnToOutStnTwo(Integer crnNo,CrnSlave.CrnStn crnStn ,Integer conStation) { try{ Date now = new Date(); // 获取堆垛机出库站信息 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo()); if (staProtocol == null) { return false; } else { staProtocol = staProtocol.clone(); } if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == null || staProtocol.getWorkNo() == 0)) { // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn,crnNo); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (conStation==1){ // 查询工作档 WrkMast wrkMast = wrkMastMapper.selectPakOutStep2345(staProtocol.getSiteId(),crnProtocol.getTaskNo().intValue()); if (wrkMast == null) { return false; } // 判断工作档条件 if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) { return false; } if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) { // 移动中 return false; } // 判断堆垛机状态等待确认 if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue()) && crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.forkPosType == CrnForkPosType.HOME && crnProtocol.getLoaded()==0) { List wrkMastSplitTwinList = wrkMastSplitTwinMapper.getWrkMastSplitTwin(wrkMast.getCrnNo(), conStation, null, 2, 3); if (wrkMastSplitTwinList.size()!=1){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",wrkMast.getCrnNo(),"不存在或者存在多笔可执行作业，请删除无效作业！！！",conStation,2,3); } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ if (wrkMastSplitTwin.getWrkNo()!=wrkMast.getWrkNo().longValue()){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={},工作任务号={},执行任务号={}",wrkMast.getCrnNo(),"工作任务与执行任务不匹配",conStation,2,3,wrkMast.getWrkNo(),wrkMastSplitTwin.getWrkNo()); return false; } // 命令下发区 -------------------------------------------------------------------------- // 下发站点信息 staProtocol.setWorkNo(wrkMast.getWrkNo()); staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo())); if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) { return false; } // 更新工作档状态为14失败 wrkMast.setWrkSts(14L); wrkMast.setCrnEndTime(now); if (wrkMastMapper.updateById(wrkMast) != 0) { wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkSts()+1); wrkMastSplitTwin.setUpdateTime(now); // 修改成功后复位堆垛机 if (wrkMastSplitTwinService.updateById(wrkMastSplitTwin)) { // 堆垛机复位 crnThread.setResetFlag(true); return true; }else { log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",wrkMast.getCrnNo(),"修改执行档案失败",conStation,2,3); } } else { log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } } } }else if (conStation==2){ if (crnProtocol.statusType != CrnStatusType.IDLE){ return false; } // 查询工作档 WrkMast wrkMast = wrkMastMapper.selectPakOutStep2345(staProtocol.getSiteId(),crnProtocol.getTaskNoTwo().intValue()); if (wrkMast == null) { return false; } // 判断工作档条件 if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) { return false; } if (crnProtocol.statusTypeTwo == CrnStatusType.FETCHING || crnProtocol.statusTypeTwo == CrnStatusType.PUTTING) { // 移动中 return false; } // 判断堆垛机状态等待确认 if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNoTwo().equals(wrkMast.getWrkNo().shortValue()) && crnProtocol.statusTypeTwo == CrnStatusType.WAITING && crnProtocol.forkPosTypeTwo == CrnForkPosType.HOME && crnProtocol.getLoadedTwo()==0) { List wrkMastSplitTwinList = wrkMastSplitTwinMapper.getWrkMastSplitTwin(wrkMast.getCrnNo(), conStation, null, 2, 3); if (wrkMastSplitTwinList.size()!=1){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",wrkMast.getCrnNo(),"不存在或者存在多笔可执行作业，请删除无效作业！！！",conStation,2,3); } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ if (wrkMastSplitTwin.getWrkNo()!=wrkMast.getWrkNo().longValue()){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={},工作任务号={},执行任务号={}",wrkMast.getCrnNo(),"工作任务与执行任务不匹配",conStation,2,3,wrkMast.getWrkNo(),wrkMastSplitTwin.getWrkNo()); return false; } // 命令下发区 -------------------------------------------------------------------------- // 下发站点信息 staProtocol.setWorkNo(wrkMast.getWrkNo()); staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo())); if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) { return false; } // 更新工作档状态为14失败 wrkMast.setWrkSts(14L); wrkMast.setCrnEndTime(now); if (wrkMastMapper.updateById(wrkMast) != 0) { wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkSts()+1); wrkMastSplitTwin.setUpdateTime(now); // 修改成功后复位堆垛机 if (wrkMastSplitTwinService.updateById(wrkMastSplitTwin)) { // 堆垛机复位 crnThread.setResetFlagTwo(true); return true; }else { log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",wrkMast.getCrnNo(),"修改执行档案失败",conStation,2,3); } } else { log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } } } } } }catch (Exception e){ log.error("更新工作档的工作状态为14失败！！！ [出库站:{}]", crnStn.getStaNo()); } return false; } public synchronized boolean crnStnToOutStnThree(CrnSlave.CrnStn crnStn ) { try{ // 获取堆垛机出库站信息 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo()); if (staProtocol == null) { return false; } else { staProtocol = staProtocol.clone(); } if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) { // 查询工作档 WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId()); if (wrkMast == null) { return false; } // 判断工作档条件 if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) { return false; } // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) { // 移动中 return false; } // 判断堆垛机状态等待确认 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))) { return false; } // 更新工作档状态为14失败 wrkMast.setWrkSts(14L); wrkMast.setCrnEndTime(new Date()); if (wrkMastMapper.updateById(wrkMast) != 0) { // 复位堆垛机 crnThread.setResetFlag(true); return true; } else { log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo()); } } } }catch (Exception e){ log.error("更新工作档的工作状态为14失败！！！ [出库站:{}]", crnStn.getStaNo()); } return false; } /** * 堆垛机站出库到出库站 */ public synchronized void crnStnToOutStnTwo() { for (CrnSlave crnSlave : slaveProperties.getCrn()) { // 遍历堆垛机出库站 for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) { switch (crnSlave.getId()){ case 3: case 4: case 5: crnStnToOutStnTwo(crnSlave.getId(),crnStn,2); continue; default: break; } } } } /** * 入出库 ===>> 堆垛机入出库作业下发 */ 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")) { switch (crn.getId()){ case 1: case 2: this.crnStnToLoc1Single(crn, crnProtocol); // 入库 break; case 3: case 4: case 5: continue; default: this.crnStnToLoc1(crn, crnProtocol,1); // 入库 } crnProtocol.setLastIo("O"); } else if (basCrnp.getOutEnable().equals("Y")) { switch (crn.getId()){ case 1: case 2: this.locToCrnStn1Single(crn, crnProtocol); // 出库 break; case 3: case 4: case 5: continue; default: this.locToCrnStn1(crn, crnProtocol,1); // 出库 } crnProtocol.setLastIo("I"); } } // 如果最近一次是出库模式 else if (crnProtocol.getLastIo().equals("O")) { if (basCrnp.getOutEnable().equals("Y")) { switch (crn.getId()){ case 1: case 2: this.locToCrnStn1Single(crn, crnProtocol); // 出库 break; case 3: case 4: case 5: continue; default: this.locToCrnStn1(crn, crnProtocol,1); // 出库 } crnProtocol.setLastIo("I"); } else if (basCrnp.getInEnable().equals("Y")) { switch (crn.getId()){ case 1: case 2: this.crnStnToLoc1Single(crn, crnProtocol); // 入库 break; case 3: case 4: case 5: continue; default: this.crnStnToLoc1(crn, crnProtocol,1); // 入库 } crnProtocol.setLastIo("O"); } } } // 库位移转 this.locToLoc(crn, crnProtocol); // this.crnRebackHp(crnProtocol, crnThread); } }catch (Exception e){ log.error("堆垛机出入库下发报错"+e); } } /** * 入出库 ===>> 堆垛机入出库作业下发 */ public synchronized void crnIoExecuteTwo() { 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; } int[] sign = new int[]{0,0}; // 只有当堆垛机空闲 并且 无任务时才继续执行 if (crnProtocol.getModeType() == CrnModeType.AUTO) { // 只有当堆垛机工位空闲 并且 无任务时才继续执行 if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) { /* * 任务拆分特殊处理 * */ if (crnProtocol.getStatusTypeTwo() == CrnStatusType.IDLE && crnProtocol.getTaskNoTwo() == 0 && crnProtocol.getLoadedTwo() == 0 && crnProtocol.getForkPosTwo() == 0){ sign[0] = 1; sign[1] = 1; } } } if (sign[0]==1){ // 如果最近一次是入库模式 if (crnProtocol.getLastIo().equals("I")) { if (basCrnp.getInEnable().equals("Y")) { switch (crn.getId()){ case 3: case 4: case 5: this.crnStnToLoc1Big(crn, crnProtocol, sign[1]); // 入库 break; default: continue; } crnProtocol.setLastIo("O"); } else if (basCrnp.getOutEnable().equals("Y")) { switch (crn.getId()){ case 3: case 4: case 5: this.locToCrnStn1Big(crn, crnProtocol, sign[1]); // 出库 break; default: continue; } crnProtocol.setLastIo("I"); } } // 如果最近一次是出库模式 else if (crnProtocol.getLastIo().equals("O")) { if (basCrnp.getOutEnable().equals("Y")) { switch (crn.getId()){ case 3: case 4: case 5: this.locToCrnStn1Big(crn, crnProtocol, sign[1]); // 出库 break; default: continue; } crnProtocol.setLastIo("I"); } else if (basCrnp.getInEnable().equals("Y")) { switch (crn.getId()){ case 3: case 4: case 5: this.crnStnToLoc1Big(crn, crnProtocol, sign[1]); // 入库 break; default: continue; } crnProtocol.setLastIo("O"); } } } // 库位移转 this.locToLoc(crn, crnProtocol); // this.crnRebackHp(crnProtocol, crnThread); } }catch (Exception e){ log.error("堆垛机出入库下发报错"+e); } } /** * 入库 ===>> 堆垛机站到库位 */ public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) { for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) { 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")) { flag = true; } if (!flag) { continue; } // 获取工作状态为2（设备上走）的入库工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo()); if (null == wrkMast) { // log.error("查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo()); 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); // 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行) // 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.toJSONString(crnCommand)); } else { // long startTime = System.currentTimeMillis(); // while ((System.currentTimeMillis() - startTime) < COMMAND_TIMEOUT) { // // if (true) { // break; // } // // try{ // Thread.sleep(500); // }catch(Exception ignore){} // } // 修改工作档状态 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()); } } } } /** * 入库 ===>> 堆垛机站到库位 * 2024-06-05 */ public synchronized void crnStnToLoc1Big(CrnSlave slave, CrnProtocol crnProtocol, Integer crnStation) { List wrkMasts = wrkMastMapper.selectPakInStep12(slave.getId()); Integer crnStation1 = crnStation;//记录 for(WrkMast wrkMast : wrkMasts){ if (wrkMast == null) { continue; } crnStation=crnStation1;//刷新 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().equals(wrkMast.getWrkNo()) && staProtocol.isInEnable() && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) { 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 (crnStation == 1){ // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { break; } // 堆垛机控制过滤 if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) { break; } }else if(crnStation == 2){ // 堆垛机控制过滤 if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) { break; } }else { break; } if (locMast.getBay1()==81){ crnStation=2; } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { continue; } // 已经存在吊车执行任务时，则过滤 if (wrkMastSplitTwinMapper.selectCount(new EntityWrapper().eq("wrk_no", wrkMast.getWrkNo().longValue())) != 0) { break; // return; } // 双深库位且浅库位有货，则需先对浅库位进行库位移转 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); // 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行) // moveLocForDeepLocPakin(slave, shallowLoc, wrkMast); } continue; } else if (shallowLoc.getLocSts().equals("Q")) { WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo); if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) { continue; } } } StaProtocol staProtocolOther = devpThread.getStation().get(crnStn.getStaNoOther()); if (staProtocolOther == null) { continue; } else { staProtocolOther = staProtocolOther.clone(); } // 查询站点详细信息 BasDevp staDetlOther = basDevpService.selectById(crnStn.getStaNoOther()); if (staDetlOther == null) { log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNoOther()); continue; } if (staProtocolOther.getWorkNo()!=0){ WrkMast wrkMastOther = wrkMastMapper.selectPakInStep3(staProtocolOther.getWorkNo()); if (Cools.isEmpty(wrkMastOther)){ log.error("Other查询工作档案无数据--工作号{},站点号：{}", staProtocolOther.getWorkNo(),staProtocolOther.getSiteId()); continue; } // 获取库位信息 LocMast locMastOther = locMastService.selectById(wrkMastOther.getLocNo()); if (locMastOther == null) { log.error("查询库存无数据--库位号{}", locMastOther.getLocNo()); continue; } if (!locMastOther.getLocSts().equals("S") && !locMastOther.getLocSts().equals("Q")) { log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMastOther.getLocNo(), locMastOther.getLocSts()); continue; } if (locMastOther.getBay1()!=81){ if (staProtocolOther.isAutoing() && staProtocolOther.isLoading() && staProtocolOther.isInEnable() && staDetlOther.getCanining() != null && staDetlOther.getCanining().equals("Y")) { // 命令下发区 -------------------------------------------------------------------------- CrnCommandParam crnCommandParam = new CrnCommandParam(); crnCommandParam.setCrnNo(slave.getId()); // 堆垛机编号 crnCommandParam.setTaskNo2(wrkMast.getWrkNo().shortValue()); // 工作号 crnCommandParam.setAckFinish2((short) 0); // 任务完成确认位 crnCommandParam.setTaskMode2(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommandParam.setSourcePosX2(crnStn.getRow().shortValue()); // 源库位排 crnCommandParam.setSourcePosY2(crnStn.getBay().shortValue()); // 源库位列 crnCommandParam.setSourcePosZ2(crnStn.getLev().shortValue()); // 源库位层 crnCommandParam.setDestinationPosX2((short)0); // 目标库位排 crnCommandParam.setDestinationPosY2((short)0); // 目标库位列 crnCommandParam.setDestinationPosZ2((short)0); // 目标库位层 crnCommandParam.setTaskNo(wrkMastOther.getWrkNo().shortValue()); // 工作号 crnCommandParam.setAckFinish((short) 0); // 任务完成确认位 crnCommandParam.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommandParam.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排 crnCommandParam.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列 crnCommandParam.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层 crnCommandParam.setDestinationPosX((short)0); // 目标库位排 crnCommandParam.setDestinationPosY((short)0); // 目标库位列 crnCommandParam.setDestinationPosZ((short)0); // 目标库位层 if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(99, crnCommandParam.getCrnNo()-2))) { log.error("输送线锁定命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), crnCommandParam.getCrnNo()-2); continue; } if (!MessageQueue.offer(SlaveType.Crn, crnCommandParam.getCrnNo(), new Task(9, crnCommandParam))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(crnCommandParam)); } else { // 修改工作档状态 2.设备上走 => 3.吊车入库中 Date now = new Date(); wrkMast.setWrkSts(3L); wrkMast.setCrnStrTime(now); wrkMast.setModiTime(now); WrkMastSplitTwin wrkMastSplitTwin = new WrkMastSplitTwin(wrkMast,2,now); wrkMastSplitTwin.setWrkSts(1); wrkMastSplitTwin.setWrkStart(wrkMast.getStaNo().toString()); wrkMastSplitTwin.setWrkEnd(wrkMast.getLocNo()); wrkMastSplitTwin.setStartRow(crnStn.getRow()); wrkMastSplitTwin.setStartBay(crnStn.getBay()); wrkMastSplitTwin.setStartLev(crnStn.getLev()); wrkMastSplitTwin.setEndRow(locMast.getRow1()); wrkMastSplitTwin.setEndBay(locMast.getBay1()); wrkMastSplitTwin.setEndLev(locMast.getLev1()); wrkMastSplitTwin.setWrkType(1); wrkMastSplitTwin.setIoType(1); wrkMastOther.setWrkSts(3L); wrkMastOther.setCrnStrTime(now); wrkMastOther.setModiTime(now); WrkMastSplitTwin wrkMastSplitTwinOther = new WrkMastSplitTwin(wrkMastOther,1,now); wrkMastSplitTwinOther.setWrkSts(1); wrkMastSplitTwinOther.setWrkStart(wrkMastOther.getStaNo().toString()); wrkMastSplitTwinOther.setWrkEnd(wrkMastOther.getLocNo()); wrkMastSplitTwinOther.setStartRow(crnStn.getRow()); wrkMastSplitTwinOther.setStartBay(crnStn.getBay()); wrkMastSplitTwinOther.setStartLev(crnStn.getLev()); wrkMastSplitTwinOther.setEndRow(locMastOther.getRow1()); wrkMastSplitTwinOther.setEndBay(locMastOther.getBay1()); wrkMastSplitTwinOther.setEndLev(locMastOther.getLev1()); wrkMastSplitTwinOther.setWrkType(1); wrkMastSplitTwinOther.setIoType(1); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo()); } if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwin)==0){ log.error("创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo()); } if (wrkMastMapper.updateById(wrkMastOther) == 0) { log.error("Other修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo()); } if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwinOther)==0){ log.error("Other创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo()); } return; } } } return; } StaProtocol staProtocolOther1 = devpThread.getStation().get(crnStn.getStaNoOther1()); if (staProtocolOther1 == null) { continue; } else { staProtocolOther1 = staProtocolOther1.clone(); } if (staProtocolOther1.isAutoing() && staProtocolOther1.getWorkNo()!=0){ return; } StaProtocol staProtocolOther2 = devpThread.getStation().get(crnStn.getStaNoOther2()); if (staProtocolOther2 == null) { continue; } else { staProtocolOther2 = staProtocolOther2.clone(); } if (staProtocolOther2.isAutoing() && staProtocolOther2.getWorkNo()!=0){ return; } crnStation = 2; // 命令下发区 -------------------------------------------------------------------------- CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommand.setSourcePosX(crnStn.getRow().shortValue()); // 源库位排 crnCommand.setSourcePosY(crnStn.getBay().shortValue()); // 源库位列 crnCommand.setSourcePosZ(crnStn.getLev().shortValue()); // 源库位层 crnCommand.setDestinationPosX((short)0); // 目标库位排 crnCommand.setDestinationPosY((short)0); // 目标库位列 crnCommand.setDestinationPosZ((short)0); // 目标库位层 staProtocol.setWorkNo(wrkMast.getWrkNo()); staProtocol.setStaNo(wrkMast.getStaNo()); devpThread.setPakMk(staProtocol.getSiteId(), false); if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(99, crnCommand.getCrnNo()-2))) { log.error("输送线锁定命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), crnCommand.getCrnNo()-2); continue; } if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(5, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(crnCommand)); } else { // 修改工作档状态 2.设备上走 => 3.吊车入库中 Date now = new Date(); wrkMast.setWrkSts(3L); wrkMast.setCrnStrTime(now); wrkMast.setModiTime(now); WrkMastSplitTwin wrkMastSplitTwin = new WrkMastSplitTwin(wrkMast,crnStation,now); wrkMastSplitTwin.setWrkSts(1); wrkMastSplitTwin.setWrkStart(wrkMast.getStaNo().toString()); wrkMastSplitTwin.setWrkEnd(wrkMast.getLocNo()); wrkMastSplitTwin.setStartRow(crnStn.getRow()); wrkMastSplitTwin.setStartBay(crnStn.getBay()); wrkMastSplitTwin.setStartLev(crnStn.getLev()); wrkMastSplitTwin.setEndRow(locMast.getRow1()); wrkMastSplitTwin.setEndBay(locMast.getBay1()); wrkMastSplitTwin.setEndLev(locMast.getLev1()); wrkMastSplitTwin.setWrkType(1); wrkMastSplitTwin.setIoType(1); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo()); } if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwin)==0){ log.error("创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo()); } break; } } } /** * 入库 ===>> 堆垛机站到库位 * 2024-01-15 煜星小料箱 */ public synchronized void crnStnToLoc1Single(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; boolean flagOther = 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(); } StaProtocol staProtocolOther = devpThread.getStation().get(crnStn.getStaNoOther()); if (staProtocolOther == null) { continue; } else { staProtocolOther = staProtocolOther.clone(); } // 查询站点详细信息 BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo()); if (staDetl == null) { log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo()); continue; } if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo().equals(wrkMast.getWrkNo()) && staProtocol.isInEnable() && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) { flag = true; } if (staProtocol.getWorkNo().equals(staProtocolOther.getWorkNo())){ continue; } // 查询站点详细信息 BasDevp staDetlOther = basDevpService.selectById(crnStn.getStaNoOther()); if (staDetlOther == null) { log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNoOther()); continue; } if (staProtocolOther.isAutoing() && staProtocolOther.isLoading() && staProtocolOther.getWorkNo() > 0 && staProtocolOther.isInEnable() && staDetlOther.getCanining() != null && staDetlOther.getCanining().equals("Y")) { flagOther = true; } if (!flag || !flagOther) { continue; } //查询堆垛机任务 WrkMastCrn wrkMastCrn = wrkMastCrnMapper.selectWrkNoOneAndTwo(wrkMast.getWrkNo()); if (Cools.isEmpty(wrkMastCrn)){ continue; } WrkMast wrkMastOther = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNoTwo().intValue()); // 获取库位信息 LocMast locMast = locMastService.selectById(Utils.getRow(wrkMastCrn.getLocNo())%4>2? wrkMastCrn.getLocNoTwo():wrkMastCrn.getLocNoOne()); if (locMast == null) { log.error("查询库存无数据--库位号{}", wrkMastCrn.getLocNo()); continue; } if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) { log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", locMast.getLocNo(), locMast.getLocSts()); continue; } // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { continue; } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { 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.toJSONString(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()); } // 修改工作档状态 2.设备上走 => 3.吊车入库中 wrkMastOther.setWrkSts(3L); wrkMastOther.setCrnStrTime(now); wrkMastOther.setModiTime(now); if (wrkMastMapper.updateById(wrkMastOther) == 0) { log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMastOther.getWrkNo()); } wrkMastCrn.setWrkSts(3L); wrkMastCrn.setModiTime(now); if (wrkMastCrnMapper.updateById(wrkMastCrn) == 0) { log.error("修改堆垛机工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMastCrn.getWrkNo()); } } } } /** * 入库 ===>> 堆垛机站到库位 * 2024-01-15 优化双工位 */ public synchronized void crnStnToLoc1(CrnSlave slave, CrnProtocol crnProtocol, Integer crnStation) { 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().equals(wrkMast.getWrkNo()) && staProtocol.isInEnable() && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) { 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 (crnStation == 1){ // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { break; } }else if(crnStation == 2){ // 堆垛机控制过滤 if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) { break; } }else { break; } // 已经存在吊车执行任务时，则过滤 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); // 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行) // 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(crnStation==1? 2:5, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(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-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库 */ public synchronized void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol) { for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) { // 获取工作状态为11（生成出库ID）的出库工作档 // WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo()); List wrkMasts = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo()); for (WrkMast wrkMast : wrkMasts) { if (wrkMast == null) { 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.getSourceLocNo(), 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) { waitWrkMast.setIoPri(15D); 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); } 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; } } } // 已经存在吊车执行任务时，则过滤 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.toJSONString(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; } } } } } /** * 出库 ===>> 库位到堆垛机站 * 2024-01-15 优化双工位 */ public synchronized void locToCrnStn1(CrnSlave slave, CrnProtocol crnProtocol, Integer crnStation) { List wrkMasts = wrkMastMapper.selectPakOutStep12(slave.getId()); for (WrkMast wrkMast : wrkMasts) { 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; } //退库模式跳过118、119出库任务 if (wrkMast.getStaNo()==118 || wrkMast.getStaNo()==119){ RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign("oneSign"); if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()==1){ continue; } } // 获取源库位信息 LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo()); if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("P")) { log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getSourceLocNo(), 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 (crnStation == 1){ // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { // continue; break; } }else if(crnStation == 2){ // 堆垛机控制过滤 if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) { // continue; break; } }else { 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) { waitWrkMast.setIoPri(15D); 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); } 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; } } } // 已经存在吊车执行任务时，则过滤 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(crnStation==1? 2:5, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(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; } } } } /** * 出库 ===>> 库位到堆垛机站 * 2024-01-15 煜星小料箱 */ public synchronized void locToCrnStn1Single(CrnSlave slave, CrnProtocol crnProtocol) { List wrkMastCrnList = wrkMastCrnMapper.selectList(new EntityWrapper() .eq("crn_no", crnProtocol.getCrnNo()).eq("wrk_sts", 11L)); for (WrkMastCrn wrkMastCrn : wrkMastCrnList) { if (wrkMastCrn == null) { continue; } CrnSlave.CrnStn crnStn = null; for (CrnSlave.CrnStn crnStn1 : slave.getCrnOutStn()){ if(crnStn1.getStaNo().equals(wrkMastCrn.getSourceStaNo())){ crnStn = crnStn1; break; } } if(Cools.isEmpty(crnStn)){ continue; } // 工作档状态判断 if (wrkMastCrn.getIoType() < 100 || wrkMastCrn.getSourceStaNo() == null) { log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMastCrn.getWrkNo(), wrkMastCrn.getSourceLocNo(), wrkMastCrn.getIoType()); continue; } // 获取源库位信息 LocMast sourceSta = locMastService.selectById(wrkMastCrn.getSourceLocNo()); if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("P")) { log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMastCrn.getSourceLocNo(), 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(); } StaProtocol staProtocolOther = devpThread.getStation().get(crnStn.getStaNoOther()); if (staProtocolOther == null) { continue; } else { staProtocolOther = staProtocolOther.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; } // 查询站点详细信息 BasDevp staDetlOther = basDevpService.selectById(crnStn.getStaNoOther()); if (staDetlOther == null) { log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNoOther()); break; // continue; } // 判断堆垛机出库站状态 if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y") && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) { if (staProtocolOther.isAutoing() && !staProtocolOther.isLoading() && staDetlOther.getCanouting() != null && staDetlOther.getCanouting().equals("Y") && staProtocolOther.getWorkNo() == 0 && staProtocolOther.isOutEnable()){ // 命令下发区 -------------------------------------------------------------------------- // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { // continue; break; } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { break; // return; } // 1.堆垛机开始移动 CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 crnCommand.setTaskNo(wrkMastCrn.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, wrkMastCrn.getCrnNo(), new Task(2, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMastCrn.getCrnNo(), JSON.toJSONString(crnCommand)); } else { // 修改工作档状态 11.生成出库ID => 12.吊车出库中 Date now = new Date(); wrkMastCrn.setWrkSts(12L); wrkMastCrn.setModiTime(now); if (wrkMastCrnMapper.updateById(wrkMastCrn) == 0) { log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMastCrn.getWrkNo()); } WrkMast wrkMastOne = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNoOne().intValue()); wrkMastOne.setWrkSts(12L); wrkMastOne.setCrnStrTime(now); wrkMastOne.setModiTime(now); if (wrkMastMapper.updateById(wrkMastOne) == 0) { log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMastOne.getWrkNo()); } WrkMast wrkMastTwo = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNoTwo().intValue()); wrkMastTwo.setWrkSts(12L); wrkMastTwo.setCrnStrTime(now); wrkMastTwo.setModiTime(now); if (wrkMastMapper.updateById(wrkMastTwo) == 0) { log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMastTwo.getWrkNo()); } break; } } } } } /** * 出库 ===>> 库位到堆垛机站 * 2024-06-05 煜星大料箱 */ public synchronized void locToCrnStn1Big(CrnSlave slave, CrnProtocol crnProtocol, Integer crnStation) { List wrkMasts = wrkMastMapper.selectPakOutStep12(slave.getId()); Integer crnStation1 = crnStation; for (WrkMast wrkMast : wrkMasts) { if (wrkMast == null) { continue; } crnStation = crnStation1; 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; } //退库模式跳过118、119出库任务 if (wrkMast.getStaNo()==118 || wrkMast.getStaNo()==119){ RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign("oneSign"); if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()==1){ continue; } } // 获取源库位信息 LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo()); if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("P")) { log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getSourceLocNo(), 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 (crnStation == 1){ // 堆垛机控制过滤 if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) { // continue; break; } // 堆垛机控制过滤 if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) { // continue; break; } }else if(crnStation == 2){ // 堆垛机控制过滤 if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) { // continue; break; } }else { break; } if (sourceSta.getBay1().shortValue()==81){ crnStation = 2; } // 双深库位且浅库位有货，则需先对浅库位进行库位移转 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) { waitWrkMast.setIoPri(15D); 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); } 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; } } } // 已经存在吊车执行任务时，则过滤 if (wrkMastMapper.selectWorking(slave.getId()) != null) { break; // return; } // 已经存在吊车执行任务时，则过滤 if (wrkMastSplitTwinMapper.selectCount(new EntityWrapper().eq("wrk_no", wrkMast.getWrkNo().longValue())) != 0) { break; // return; } if (true){ // 1.堆垛机开始移动 CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排 crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列 crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层 crnCommand.setDestinationPosX((short)0); // 目标库位排 crnCommand.setDestinationPosY((short)0); // 目标库位列 crnCommand.setDestinationPosZ((short)0); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(crnCommand)); } else { // 修改工作档状态 11.生成出库ID => 12.吊车出库中 Date now = new Date(); wrkMast.setWrkSts(12L); wrkMast.setCrnStrTime(now); wrkMast.setModiTime(now); WrkMastSplitTwin wrkMastSplitTwin = new WrkMastSplitTwin(wrkMast,crnStation,now); wrkMastSplitTwin.setWrkSts(1); wrkMastSplitTwin.setWrkStart(wrkMast.getSourceLocNo()); wrkMastSplitTwin.setWrkEnd(wrkMast.getSourceStaNo().toString()); wrkMastSplitTwin.setStartRow(sourceSta.getRow1()); wrkMastSplitTwin.setStartBay(sourceSta.getBay1()); wrkMastSplitTwin.setStartLev(sourceSta.getLev1()); wrkMastSplitTwin.setEndRow(crnStn.getRow()); wrkMastSplitTwin.setEndBay(crnStn.getBay()); wrkMastSplitTwin.setEndLev(crnStn.getLev()); wrkMastSplitTwin.setWrkType(1); wrkMastSplitTwin.setIoType(2); if (wrkMastMapper.updateById(wrkMast) == 0) { log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo()); } if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwin)==0){ log.error("创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo()); } break; } } // else { // // 1.堆垛机开始移动 // CrnCommandParam crnCommandParam = new CrnCommandParam(); // CrnCommand crnCommand = new CrnCommand(); // crnCommand.setCrnNo(slave.getId()); // 堆垛机编号 // crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号 // crnCommand.setAckFinish((short) 0); // 任务完成确认位 // crnCommand.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 // crnCommand.setSourcePosX(sourceSta.getRow1().shortValue()); // 源库位排 // crnCommand.setSourcePosY(sourceSta.getBay1().shortValue()); // 源库位列 // crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue()); // 源库位层 // crnCommand.setDestinationPosX((short)0); // 目标库位排 // crnCommand.setDestinationPosY((short)0); // 目标库位列 // crnCommand.setDestinationPosZ((short)0); // 目标库位层 // if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) { // log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(crnCommand)); // } else { // // 修改工作档状态 11.生成出库ID => 12.吊车出库中 // Date now = new Date(); // wrkMast.setWrkSts(12L); // wrkMast.setCrnStrTime(now); // wrkMast.setModiTime(now); // WrkMastSplitTwin wrkMastSplitTwin = new WrkMastSplitTwin(wrkMast,crnStation,now); // wrkMastSplitTwin.setWrkSts(1); // wrkMastSplitTwin.setWrkStart(wrkMast.getSourceLocNo()); // wrkMastSplitTwin.setWrkEnd(wrkMast.getSourceStaNo().toString()); // wrkMastSplitTwin.setStartRow(sourceSta.getRow1()); // wrkMastSplitTwin.setStartBay(sourceSta.getBay1()); // wrkMastSplitTwin.setStartLev(sourceSta.getLev1()); // wrkMastSplitTwin.setEndRow(crnStn.getRow()); // wrkMastSplitTwin.setEndBay(crnStn.getBay()); // wrkMastSplitTwin.setEndLev(crnStn.getLev()); // wrkMastSplitTwin.setWrkType(1); // wrkMastSplitTwin.setIoType(2); // if (wrkMastMapper.updateById(wrkMast) == 0) { // log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo()); // } // // if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwin)==0){ // log.error("创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo()); // } // break; // } // } } } } /** * 库位移转 */ 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.toJSONString(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()); } } } /** * 执行对工作档的完成操作 */ public synchronized void storeFinished() { for (CrnSlave crn : slaveProperties.getCrn()) { switch (crn.getId()){ case 1: case 2: storeFinishedExecuteOne(crn); continue; case 3: case 4: case 5: storeFinishedExecuteTwo(crn); continue; case 6: case 7: storeFinishedExecuteThree(crn); continue; default: continue; } } } public synchronized boolean storeFinishedExecuteOne(CrnSlave crn) { try{ // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { return false; } if (crnProtocol.modeType != CrnModeType.AUTO){ return false; } // 状态：等待确认 并且 任务完成位 = 1 if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) { if (crnProtocol.getTaskNo() == 32222) { // 堆垛机复位 crnThread.setResetFlag(true); } else { // 获取入库待确认工作档 WrkMastCrn wrkMastCrn = wrkMastCrnMapper.selectWrkNoOneAndTwo(crnProtocol.getTaskNo().intValue()); if (wrkMastCrn == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo()); return false; } // 获取入库待确认工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue()); if (wrkMast == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo()); return false; } // 获取入库待确认工作档 WrkMast wrkMastOther = wrkMastMapper.selectPakInStep3(wrkMastCrn.getWrkNoTwo().intValue()); if (wrkMastOther == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo()); return false; } // 入库 + 库位转移 ==> 4.入库完成 if (wrkMastCrn.getWrkSts() == 3 || (wrkMastCrn.getWrkSts() == 12 && wrkMastCrn.getIoType() == 11)) { wrkMastCrn.setWrkSts(4L); } else { return false; } Date now = new Date(); wrkMastCrn.setModiTime(now); wrkMast.setCrnEndTime(now); wrkMast.setWrkSts(4L); wrkMast.setModiTime(now); wrkMastOther.setCrnEndTime(now); wrkMastOther.setWrkSts(4L); wrkMastOther.setModiTime(now); // 修改成功后复位堆垛机 if (wrkMastCrnMapper.updateById(wrkMastCrn) > 0 && wrkMastMapper.updateById(wrkMast) > 0 && wrkMastMapper.updateById(wrkMastOther) > 0 ) { // 堆垛机复位 crnThread.setResetFlag(true); return true; } } } }catch (Exception e){ log.error("堆垛机工位一完成等待确认异常,堆垛机号={},异常信息={},工位号={}",crn.getId(),e.getMessage(),1); } return false; } public synchronized boolean storeFinishedExecuteTwo(CrnSlave crn) { try{ // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { return false; } if (crnProtocol.modeType != CrnModeType.AUTO){ return false; } // 状态：等待确认 并且 任务完成位 = 1 if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) { if (crnProtocol.getTaskNo() == 32222) { // 堆垛机复位 crnThread.setResetFlag(true); return true; } else { // 获取入库待确认工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue()); if (wrkMast == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo()); return false; } // 入库 + 库位转移 ==> 4.入库完成 if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) { wrkMast.setWrkSts(4L); } else { return false; } Date now = new Date(); wrkMast.setCrnEndTime(now); wrkMast.setModiTime(now); // 堆垛机复位 List wrkMastSplitTwinList = wrkMastSplitTwinMapper.getWrkMastSplitTwin(crn.getId(), 1, null, 2, 3); if (wrkMastSplitTwinList.size()!=1){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"不存在或者存在多笔可执行作业，请删除无效作业！！！",1,2,3); } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ if (wrkMastSplitTwin.getWrkNo()!=wrkMast.getWrkNo().longValue()){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={},工作任务号={},执行任务号={}",crn.getId(),"工作任务与执行任务不匹配",1,2,3,wrkMast.getWrkNo(),wrkMastSplitTwin.getWrkNo()); return false; } wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkSts()+1); wrkMastSplitTwin.setUpdateTime(now); // 修改成功后复位堆垛机 if (wrkMastMapper.updateById(wrkMast) > 0) { // 修改成功后复位堆垛机 if (wrkMastSplitTwinService.updateById(wrkMastSplitTwin)) { // 堆垛机复位 crnThread.setResetFlag(true); return true; }else { log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"修改执行档案失败",1,2,3); } }else { log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"修改工作档案失败！",1,2,3); } } return false; } }else if (crnProtocol.statusType == CrnStatusType.SEPARATE_WAITING && crnProtocol.getTaskNo() != 0 && crnProtocol.getLoaded()==1){ if (crnProtocol.getTaskNo() == 32222) { // 堆垛机复位 crnThread.setResetFlag(true); return true; } else { List wrkMastSplitTwinList = wrkMastSplitTwinMapper.getWrkMastSplitTwin(crn.getId(), 1, null, 1, 1); if (wrkMastSplitTwinList.size()!=1){ log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"不存在或者存在多笔可执行作业，请删除无效作业！！！",1,1,1); } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ Date now = new Date(); wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkSts()+1); wrkMastSplitTwin.setUpdateTime(now); // 修改成功后复位堆垛机 if (wrkMastSplitTwinService.updateById(wrkMastSplitTwin)) { // 堆垛机复位 crnThread.setResetFlag(true); return true; }else { log.error("堆垛机放货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"修改执行档案失败",1,2,3); } } } } }catch (Exception e){ log.error("堆垛机工位一完成等待确认异常,堆垛机号={},异常信息={},工位号={}",crn.getId(),e.getMessage(),1); } return false; } public synchronized boolean storeFinishedExecuteThree(CrnSlave crn) { try{ // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { return false; } if (crnProtocol.modeType != CrnModeType.AUTO){ return false; } // 状态：等待确认 并且 任务完成位 = 1 if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) { if (crnProtocol.getTaskNo() == 32222) { // 堆垛机复位 crnThread.setResetFlag(true); } else { // 获取入库待确认工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue()); if (wrkMast == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo()); return false; } // 入库 + 库位转移 ==> 4.入库完成 if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) { wrkMast.setWrkSts(4L); } else { return false; } Date now = new Date(); wrkMast.setCrnEndTime(now); wrkMast.setModiTime(now); // 修改成功后复位堆垛机 if (wrkMastMapper.updateById(wrkMast) > 0) { // 堆垛机复位 crnThread.setResetFlag(true); return true; } } } }catch (Exception e){ log.error("堆垛机工位一完成等待确认异常,堆垛机号={},异常信息={},工位号={}",crn.getId(),e.getMessage(),1); } return false; } /** * 执行对工作档的完成操作 */ public synchronized void storeFinishedTwo() { for (CrnSlave crn : slaveProperties.getCrn()) { switch (crn.getId()){ case 3: case 4: case 5: storeFinishedTwoExecute(crn); continue; default: continue; } } } public synchronized boolean storeFinishedTwoExecute(CrnSlave crn) { try{ // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { return false; } if (crnProtocol.modeType != CrnModeType.AUTO){ return false; } // 状态：等待确认 并且 任务完成位 = 1 if (crnProtocol.statusTypeTwo == CrnStatusType.WAITING && crnProtocol.getTaskNoTwo() != 0) { if (crnProtocol.getTaskNoTwo() == 32222) { // 堆垛机复位 crnThread.setResetFlagTwo(true); } else { // 获取入库待确认工作档 WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNoTwo().intValue()); if (wrkMast == null) { log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNoTwo()); return false; } // 入库 + 库位转移 ==> 4.入库完成 if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) { wrkMast.setWrkSts(4L); } else { return false; } Date now = new Date(); wrkMast.setCrnEndTime(now); wrkMast.setModiTime(now); // 堆垛机复位 List wrkMastSplitTwinList = wrkMastSplitTwinMapper.getWrkMastSplitTwin(crn.getId(), 2, null, 2, 3); if (wrkMastSplitTwinList.size()!=1){ log.error("堆垛机取货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"不存在或者存在多笔可执行作业，请删除无效作业！！！",2,2,3); } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ if (wrkMastSplitTwin.getWrkNo()!=wrkMast.getWrkNo().longValue()){ log.error("堆垛机取货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={},工作任务号={},执行任务号={}",crn.getId(),"工作任务与执行任务不匹配",1,2,3,wrkMast.getWrkNo(),wrkMastSplitTwin.getWrkNo()); return false; } wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkSts()+1); wrkMastSplitTwin.setUpdateTime(now); // 修改成功后复位堆垛机 if (wrkMastMapper.updateById(wrkMast) > 0) { // 修改成功后复位堆垛机 if (wrkMastSplitTwinService.updateById(wrkMastSplitTwin)) { // 堆垛机复位 crnThread.setResetFlagTwo(true); return true; }else { log.error("堆垛机取货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"修改执行档案失败",2,2,3); } }else { log.error("堆垛机取货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"修改工作档案失败！",2,2,3); } } return false; } }else if (crnProtocol.statusTypeTwo == CrnStatusType.SEPARATE_WAITING && crnProtocol.getTaskNoTwo() != 0 && crnProtocol.getLoadedTwo()==1){ if (crnProtocol.getTaskNoTwo() == 32222) { // 堆垛机复位 crnThread.setResetFlagTwo(true); } else { List wrkMastSplitTwinList = wrkMastSplitTwinMapper.getWrkMastSplitTwin(crn.getId(), 2, null, 1, 1); if (wrkMastSplitTwinList.size()!=1){ log.error("堆垛机取货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"不存在或者存在多笔可执行作业，请删除无效作业！！！",2,1,1); } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ Date now = new Date(); wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkSts()+1); wrkMastSplitTwin.setUpdateTime(now); // 修改成功后复位堆垛机 if (wrkMastSplitTwinService.updateById(wrkMastSplitTwin)) { // 堆垛机复位 crnThread.setResetFlagTwo(true); return true; }else { log.error("堆垛机取货完成等待确认异常,堆垛机号={},异常信息={},工位号={},工作类型={},工作状态={}",crn.getId(),"修改执行档案失败",2,2,3); } } } } }catch (Exception e){ log.error("堆垛机工位二完成等待确认异常,堆垛机号={},异常信息={},工位号={}",crn.getId(),e.getMessage(),2); } return false; } /** * 异常信息记录 */ public synchronized void recErr() { try { this.recCrnErr(); this.recRgvErr(); } catch (Exception e) { log.error("recErr fail", e); } } /** * RGV异常信息记录 */ public synchronized void recRgvErr() { Date now = new Date(); for (RgvSlave rgv : slaveProperties.getRgv()) { // 获取RGV信息 RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId()); RgvProtocol rgvProtocol = rgvThread.getRgvProtocol(); if (rgvProtocol == null) { continue; } if (true) { // 有任务 if (rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getTaskNo2() != 0) { Integer taskNo = rgvProtocol.getTaskNo1() > 0 ? rgvProtocol.getTaskNo1().intValue() : rgvProtocol.getTaskNo2().intValue(); BasRgvErrLog latest = basRgvErrLogService.findLatestByTaskNo(rgv.getId(), taskNo); // 有异常 if (latest == null) { if (rgvProtocol.getAlarm() != null && rgvProtocol.getAlarm() > 0) { WrkMast wrkMast = wrkMastMapper.selectById(taskNo); if (wrkMast == null) { continue; } BasRgvErr rgvErr = basRgvErrMapper.selectById(rgvProtocol.getAlarm()); String errName = rgvErr == null ? String.valueOf(rgvProtocol.getAlarm()) : rgvErr.getErrName(); BasRgvErrLog basRgvErrLog = new BasRgvErrLog( null, // 编号 wrkMast.getWrkNo(), // 工作号 now, // 发生时间 null, // 结束时间 wrkMast.getWrkSts(), // 工作状态 wrkMast.getIoType(), // 入出库类型 rgv.getId(), // 堆垛机 null, // plc wrkMast.getLocNo(), // 目标库位 wrkMast.getStaNo(), // 目标站 wrkMast.getSourceStaNo(), // 源站 wrkMast.getSourceLocNo(), // 源库位 wrkMast.getBarcode(), // 条码 (int) rgvProtocol.getAlarm(), // 异常码 errName, // 异常 1, // 异常情况 now, // 添加时间 null, // 添加人员 now, // 修改时间 null, // 修改人员 "任务中异常" // 备注 ); if (!basRgvErrLogService.insert(basRgvErrLog)) { log.error("RGV异常记录失败 ===>> [id:{}] [error:{}]", rgv.getId(), errName); } } } else { // 异常修复 if (rgvProtocol.getAlarm() == null || rgvProtocol.getAlarm() == 0) { latest.setEndTime(now); latest.setUpdateTime(now); latest.setStatus(2); if (!basRgvErrLogService.updateById(latest)) { log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", rgv.getId(), latest.getId()); } } } // 无任务 } else { BasRgvErrLog latest = basRgvErrLogService.findLatest(rgv.getId()); // 有异常 if (rgvProtocol.getAlarm() != null && rgvProtocol.getAlarm() > 0) { // 记录新异常 if (latest == null || (latest.getErrCode() != rgvProtocol.getAlarm().intValue())) { BasRgvErr rgvErr = basRgvErrMapper.selectById(rgvProtocol.getAlarm()); String errName = rgvErr == null ? String.valueOf(rgvProtocol.getAlarm()) : rgvErr.getErrName(); BasRgvErrLog basRgvErrLog = new BasRgvErrLog( null, // 编号 null, // 工作号 now, // 发生时间 null, // 结束时间 null, // 工作状态 null, // 入出库类型 rgv.getId(), // 堆垛机 null, // plc null, // 目标库位 null, // 目标站 null, // 源站 null, // 源库位 null, // 条码 (int) rgvProtocol.getAlarm(), // 异常码 errName, // 异常 1, // 异常情况 now, // 添加时间 null, // 添加人员 now, // 修改时间 null, // 修改人员 "无任务异常" // 备注 ); if (!basRgvErrLogService.insert(basRgvErrLog)) { log.error("RGV异常记录失败 ===>> [id:{}] [error:{}]", rgv.getId(), errName); } } // 无异常 } else { // 异常修复 if (latest != null && latest.getStatus() == 1) { latest.setEndTime(now); latest.setUpdateTime(now); latest.setStatus(2); if (!basRgvErrLogService.updateById(latest)) { log.error("RGV异常记录修复失败 ===>> [id:{}] [errLogId:{}]", rgv.getId(), latest.getId()); } } } } } } } /** * 堆垛机异常信息记录 */ public synchronized void recCrnErr() { Date now = new Date(); for (CrnSlave crn : slaveProperties.getCrn()) { // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { continue; } if (true) { // if (crnProtocol.getModeType() != CrnModeType.STOP) { // 有任务 if (crnProtocol.getTaskNo() != 0) { BasErrLog latest = basErrLogService.findLatestByTaskNo(crn.getId(), crnProtocol.getTaskNo().intValue()); // 有异常 if (latest == null) { if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) { WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo()); if (wrkMast == null) { continue; } BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm()); String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName(); BasErrLog basErrLog = new BasErrLog( null, // 编号 wrkMast.getWrkNo(), // 工作号 now, // 发生时间 null, // 结束时间 wrkMast.getWrkSts(), // 工作状态 wrkMast.getIoType(), // 入出库类型 crn.getId(), // 堆垛机 null, // plc wrkMast.getLocNo(), // 目标库位 wrkMast.getStaNo(), // 目标站 wrkMast.getSourceStaNo(), // 源站 wrkMast.getSourceLocNo(), // 源库位 wrkMast.getBarcode(), // 条码 (int) crnProtocol.getAlarm(), // 异常码 errName, // 异常 1, // 异常情况 now, // 添加时间 null, // 添加人员 now, // 修改时间 null, // 修改人员 "任务中异常" // 备注 ); if (!basErrLogService.insert(basErrLog)) { log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName); } } } else { // 异常修复 if (crnProtocol.getAlarm() == null || crnProtocol.getAlarm() == 0) { latest.setEndTime(now); latest.setUpdateTime(now); latest.setStatus(2); if (!basErrLogService.updateById(latest)) { log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId()); } } } // 无任务 } else { BasErrLog latest = basErrLogService.findLatest(crn.getId()); // 有异常 if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) { // 记录新异常 if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) { BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm()); String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName(); BasErrLog basErrLog = new BasErrLog( null, // 编号 null, // 工作号 now, // 发生时间 null, // 结束时间 null, // 工作状态 null, // 入出库类型 crn.getId(), // 堆垛机 null, // plc null, // 目标库位 null, // 目标站 null, // 源站 null, // 源库位 null, // 条码 (int) crnProtocol.getAlarm(), // 异常码 errName, // 异常 1, // 异常情况 now, // 添加时间 null, // 添加人员 now, // 修改时间 null, // 修改人员 "无任务异常" // 备注 ); if (!basErrLogService.insert(basErrLog)) { log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName); } } // 无异常 } else { // 异常修复 if (latest != null && latest.getStatus() == 1) { latest.setEndTime(now); latest.setUpdateTime(now); latest.setStatus(2); if (!basErrLogService.updateById(latest)) { log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId()); } } } } } } } // ------------------------------------------------------------------------------- /** * 空栈板初始化入库,叉车入库站放货 */ 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 (emptyInSta.getStaNo()==607 && staProtocol.getStaNo()==607 && staProtocol.getWorkNo()>20000 && staProtocol.isLoading() && staProtocol.isAutoing()){ try { BasDevp basDevp = basDevpService.selectById(staProtocol.getStaNo()); if (basDevp.getReportSign()==0){ 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)) { basDevp.setReportSign(1); basDevpService.updateById(basDevp); StartupDto dto = jsonObject.getObject("data", StartupDto.class); // 更新站点信息 且 下发plc命令 staProtocol.setWorkNo(dto.getWorkNo()); staProtocol.setStaNo(607); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(5, staProtocol)); if (!result) { 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(); } return; } // 站点条件判断 if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isEmptyMk() && ((staProtocol.getWorkNo() > 32222 && staProtocol.getWorkNo() <= 63333) || 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()); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { 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 storeEmptyPltSingle() { for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历空板入库口 for (DevpSlave.Sta emptyInSta : devp.getEmptyInSingleSta()) { // 获取空板入库站信息 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() > 32222 && staProtocol.getWorkNo() <= 63333) || staProtocol.getWorkNo()==0) && staProtocol.isPakMk()) { //回库标记 if (emptyInSta.getStaNo()==126 || emptyInSta.getStaNo()==131){ RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign("sign"+emptyInSta.getStaNo()); if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()!=1){ continue; } } 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/pair/station/single/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()); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { throw new CoolException("更新plc站点信息失败"); } } else { log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/pair/station/single/loc/v1", JSON.toJSONString(param), response); } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * 空栈板初始化入库,叉车入库站放货 */ public synchronized void storeEmptyPltLarge() { for (DevpSlave devp : slaveProperties.getDevp()) { // 遍历空板入库口 for (DevpSlave.Sta emptyInSta : devp.getEmptyInLargeSta()) { // 获取空板入库站信息 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() > 32222 && staProtocol.getWorkNo() <= 63333) || staProtocol.getWorkNo()==0) && staProtocol.isPakMk()) { //回库标记 if (emptyInSta.getStaNo()==310 || emptyInSta.getStaNo()==312){ RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign("sign"+emptyInSta.getStaNo()); if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()!=1){ continue; } } 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()); devpThread.setPakMk(staProtocol.getSiteId(), false); boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol)); if (!result) { 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(); } } } } } /** * 入库 ===>> 空栈板初始化入库,1楼叠盘机叠盘 */ public synchronized void storeEmptyPlt2() { for (DevpSlave devp : slaveProperties.getDevp()) { if (devp.getId()==2) 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() > 32222 && staProtocol.getWorkNo() <= 63333) || staProtocol.getWorkNo()==0) && staProtocol.isPakMk()) { try { WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(staProtocol.getSiteId() + 19999L); if (Cools.isEmpty(wrkMastSta)){ WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),staProtocol.getSiteId()); wrkMastSta1.setType(2); wrkMastSta1.setWrkType(1);//工作类型 1:取（叠盘） 2：拆盘 3：取放 5：满取 6：满放 wrkMastStaMapper.insert(wrkMastSta1); } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } } } /** * 空栈板初始化入库,叉车入库站放货 */ public synchronized void storeEmptyPlt3() { try{ RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign("oneSign"); if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()==1){ return; } for (RgvSlave rgvSlave:slaveProperties.getRgv()) { RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId()); RgvProtocol rgvProtocol = rgvThread.getRgvProtocol(); if (rgvProtocol == null) { continue; } BasRgv basRgv = basRgvService.selectById(rgvSlave.getId()); if (basRgv == null) { log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId()); continue; } // 只有当RGV空闲、自动,工位二有物//rgv可用 if (rgvProtocol.getStatusType() == RgvStatusType.IDLE && rgvProtocol.getModeType() == RgvModeType.AUTO && rgvProtocol.getStatusType1() == RgvStatusType.IDLE && rgvProtocol.getStatusType2() == RgvStatusType.IDLE && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0 // && (rgvProtocol.getLoaded2()==2 || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物 ；2一层有物二层无物 （只能满放）；3 1、2层都有物 4：（）只允许拆盘 && rgvProtocol.getLoaded2()==3 ////0 无物；1 一层无物二层有物 ；2一层有物二层无物 （只能满放）；3 1、2层都有物 4：（）只允许拆盘 ) { try { WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep3(122); if (!Cools.isEmpty(wrkMast1)){ continue; } // 获取空板入库站信息 SearchLocParam param = new SearchLocParam(); param.setIoType(10); param.setSourceStaNo(122); param.setLocType1((short)1); String response = new HttpHandler.Builder() .setUri(wmsUrl) .setPath("/rpc/pakin/empty/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命令 WrkMast wrkMast = wrkMastMapper.selectPakInStep3(dto.getWorkNo()); if (!Cools.isEmpty(wrkMast) && wrkMast.getIoType()==10 && wrkMast.getWrkSts()==2){ WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(wrkMast.getWrkNo().longValue()); if (Cools.isEmpty(wrkMastSta)){ WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),wrkMast.getStaNo()); wrkMastSta1.setWrkNo(wrkMast.getWrkNo().longValue()); wrkMastSta1.setType(2); wrkMastSta1.setWrkType(6);//工作类型 1:取（叠盘） 2：拆盘 3：取放 5：满取 6：满放 wrkMastStaMapper.insert(wrkMastSta1); } } } else { log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/empty/loc/v1", JSON.toJSONString(param), response); } } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } }catch (Exception e){ log.error("3933行执行小车放空板任务下发失败"); log.error("3933行"+e); } } /** * 出库 ===>> 工作档信息写入led显示器 */ public synchronized void ledExecute() { for (LedSlave led : slaveProperties.getLed()) { // 获取输送线plc线程 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId()); // 命令集合 List commands = new ArrayList<>(); // 工作档集合 List wrkMasts = new ArrayList<>(); for (Integer staNo : led.getStaArr()) { // 获取叉车站点 StaProtocol staProtocol = devpThread.getStation().get(staNo); if (null == staProtocol || null == staProtocol.getWorkNo() || 0 == staProtocol.getWorkNo() || !staProtocol.isLoading()) { continue; } else { staProtocol = staProtocol.clone(); } // 获取工作档数据 WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo()); // if (null == wrkMast || wrkMast.getWrkSts() < 14 || wrkMast.getIoType() < 100) { continue; } if (null == wrkMast) { continue; } wrkMasts.add(wrkMast); // 组装命令 LedCommand ledCommand = new LedCommand(); ledCommand.setWorkNo(wrkMast.getWrkNo()); ledCommand.setIoType(wrkMast.getIoType()); // 出库模式 switch (wrkMast.getIoType()) { case 1: case 202: ledCommand.setTitle("全板入库"); break; case 10: ledCommand.setTitle("空板入库"); break; case 101: ledCommand.setTitle("全板出库"); break; case 103: ledCommand.setTitle("拣料出库"); break; case 104: ledCommand.setTitle("并板出库"); break; case 107: ledCommand.setTitle("盘点出库"); break; case 110: ledCommand.setTitle("空板出库"); ledCommand.setEmptyMk(true); break; case 212: ledCommand.setTitle("空板出库"); ledCommand.setEmptyMk(true); break; default: log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType()); break; } ledCommand.setSourceLocNo(wrkMast.getSourceLocNo()); ledCommand.setLocNo(wrkMast.getLocNo()); ledCommand.setStaNo(wrkMast.getStaNo()); // ledCommand.setSourceStaNo(wrkMast.getSourceStaNo()); if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) { List wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo()); wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl))); } commands.add(ledCommand); } Set workNos = wrkMasts.stream().map(WrkMast::getWrkNo).collect(Collectors.toSet()); // 获取LED线程 LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId()); // 相同工作号集合则过滤 if (CollectionUtils.equals(ledThread.getWorkNos(), workNos)) { continue; } // 命令下发 ------------------------------------------------------------------------------- if (!commands.isEmpty()) { // if (led.getId() == 7) { if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(3, commands))) { log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort()); continue; } else { ledThread.setLedMk(false); } // } // else { // if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) { // log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort()); // continue; // } else { // ledThread.setLedMk(false); // } // } } try { // 修改主档led标记 for (WrkMast wrkMast : wrkMasts) { wrkMast.setOveMk("Y"); wrkMast.setModiTime(new Date()); if (wrkMastMapper.updateById(wrkMast) == 0) { throw new CoolException("更新工作档失败"); } } // 更新线程当前工作号集合 ledThread.setWorkNos(workNos); } catch (Exception e) { e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } } /** * 其他 ===>> LED显示器复位，显示默认信息 */ public synchronized void ledReset() { for (LedSlave led : slaveProperties.getLed()) { // 获取输送线plc线程 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId()); // 命令集合 boolean reset = true; for (Integer staNo : led.getStaArr()) { // 获取叉车站点 StaProtocol staProtocol = devpThread.getStation().get(staNo); if (staProtocol == null) { continue; } if (staProtocol.getWorkNo() != 0 && staProtocol.isLoading()) { reset = false; break; } } // 获取led线程 LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId()); // led显示默认内容 if (reset && !ledThread.isLedMk()) { if (led.getId() == 7) { ledThread.setLedMk(true); if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(4, new ArrayList<>()))) { log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort()); } else { } } else { ledThread.setLedMk(true); if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) { log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort()); } else { } } } } } /** * 因双深库位阻塞，对浅库位进行移转（入库版) * tip：同步 */ @Transactional public synchronized void moveLocForDeepLocPakin(CrnSlave crn, LocMast shallowLoc, WrkMast pakinWrkMast) { LocMast loc = locMastService.selectById(pakinWrkMast.getLocNo()); // 获取工作号 int workNo = commonService.getWorkNo(0); Date now = new Date(); // 保存工作档 WrkMast wrkMast = new WrkMast(); wrkMast.setWrkNo(workNo); wrkMast.setIoTime(now); wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID wrkMast.setIoType(11); // 入出库状态： 11.库格移载 wrkMast.setIoPri(15D); 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.setCtnNo("Y"); // 入库阻塞库位移转标记 wrkMast.setAppeTime(now); wrkMast.setModiTime(now); int res = wrkMastMapper.insert(wrkMast); if (res == 0) { 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(now); wrkDetl.setAnfme(locDetl.getAnfme()); VersionUtils.setWrkDetl(wrkDetl, locDetl); // 版本控制 wrkDetl.setAppeTime(now); wrkDetl.setModiTime(now); if (!wrkDetlService.insert(wrkDetl)) { throw new CoolException("保存工作档明细失败"); } } } // 修改源库位状态 if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) { shallowLoc.setLocSts("S"); // S.入库预约，入库阻塞库位移转 shallowLoc.setModiTime(now); if (!locMastService.updateById(shallowLoc)) { throw new CoolException("更新源库位状态失败"); } } else { throw new CoolException("源库位出库失败"); } // // 修改目标库位状态 // if (loc.getLocSts().equals("O")) { // loc.setLocSts("S"); // S.入库预约 // loc.setModiTime(new Date()); // if (!locMastService.updateById(loc)) { // throw new CoolException("更新目标库位状态失败"); // } // } else { // throw new CoolException("移转失败"); // } wrkMast.setLocNo(shallowLoc.getLocNo()); if (wrkMastMapper.updateById(wrkMast) == 0) { throw new CoolException("修改阻塞入库任务失败"); } } /** * 因双深库位阻塞，对浅库位进行移转（立即执行版) * tip：同步 */ private synchronized void 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()); throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo()); } // 获取工作号 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) { 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)) { throw new CoolException("保存工作档明细失败"); } } } // 修改源库位状态 if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) { shallowLoc.setLocSts("R"); // R.出库预约 shallowLoc.setModiTime(new Date()); if (!locMastService.updateById(shallowLoc)) { throw new CoolException("更新源库位状态失败"); } } else { throw new CoolException("源库位出库失败"); } // 修改目标库位状态 if (loc.getLocSts().equals("O")) { loc.setLocSts("S"); // S.入库预约 loc.setModiTime(new Date()); if (!locMastService.updateById(loc)) { throw new CoolException("更新目标库位状态失败"); } } else { throw new CoolException("移转失败"); } } catch (Exception e) { log.error("双深库位阻塞，对浅库位进行移转失败", e); e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } /** * 堆垛机演示 ===>> 库位移转 */ public synchronized void crnDemoOfLocMove1() { try { for (CrnSlave crn : slaveProperties.getCrn()) { if (!crn.getDemo()) { continue; } // 必须为演示状态 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { continue; } // 只有当堆垛机空闲 并且 无任务时才继续执行 if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) { // 获取移库工作档信息 WrkMast wrkMast = wrkMastMapper.selectLocMove(crn.getId()); if (null != wrkMast) { continue; } LocMast sourceLoc = locMastService.queryDemoSourceLoc(crn.getId()); LocMast loc = locMastService.queryDemoLoc(crn.getId()); if (null == sourceLoc || null == loc) { continue; } String sourceLocNo = sourceLoc.getLocNo(); String locNo = loc.getLocNo(); // 获取工作号 int workNo = commonService.getWorkNo(0); // 保存工作档 wrkMast = new WrkMast(); wrkMast.setWrkNo(workNo); wrkMast.setIoTime(new Date()); wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID wrkMast.setIoType(11); // 入出库状态： 11.库格移载 wrkMast.setIoPri(13D); wrkMast.setCrnNo(crn.getId()); wrkMast.setSourceLocNo(sourceLocNo); // 源库位 wrkMast.setLocNo(locNo); // 目标库位 wrkMast.setFullPlt("N"); // 满板：Y wrkMast.setPicking("N"); // 拣料 wrkMast.setExitMk("N"); // 退出 wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板 wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码 wrkMast.setLinkMis("N"); wrkMast.setAppeTime(new Date()); wrkMast.setModiTime(new Date()); int res = wrkMastMapper.insert(wrkMast); if (res == 0) { throw new CoolException("保存工作档失败"); } // 工作档明细保存 // List locDetls = locDetlService.selectList(new EntityWrapper().eq("loc_no", sourceLocNo)); // 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)) { // throw new CoolException("保存工作档明细失败"); // } // } // 修改源库位状态 if (sourceLoc.getLocSts().equals("D")) { sourceLoc.setLocSts("R"); // R.出库预约 sourceLoc.setModiTime(new Date()); if (!locMastService.updateById(sourceLoc)) { throw new CoolException("更新源库位状态失败"); } } else { throw new CoolException("源库位出库失败"); } // 修改目标库位状态 if (loc.getLocSts().equals("O")) { loc.setLocSts("S"); // S.入库预约 loc.setModiTime(new Date()); if (!locMastService.updateById(loc)) { throw new CoolException("更新目标库位状态失败"); } } else { throw new CoolException("移转失败"); } } } } catch (Exception e) { log.error("堆垛机演示 ===>> 库位移转失败", e); e.printStackTrace(); TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } } /** * 入出库 ===>> 小车作业下发 */ public synchronized boolean steIoExecute(Integer sign) { return false; } /** * 入出库 ===>> 堆垛机入出库作业下发 */ public synchronized void crnIoExecuteTwoExecute(Integer i) { for (CrnSlave crn : slaveProperties.getCrn()) { try{ switch (crn.getId()){ case 3: case 4: case 5: crnWrkMastSplitTwinExecute(crn,i); continue; default: continue; } }catch (Exception e){ log.error("堆垛机出入库执行任务下发报错,堆垛机号={},异常信息={}",crn.getId(),e.getMessage()); } } } public synchronized boolean crnWrkMastSplitTwinExecute(CrnSlave crn,Integer i){ try{ // 获取堆垛机信息 CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId()); CrnProtocol crnProtocol = crnThread.getCrnProtocol(); if (crnProtocol == null) { return false; } BasCrnp basCrnp = basCrnpService.selectById(crn.getId()); if (basCrnp == null) { log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId()); return false; } int[] sign = new int[]{0,0}; // 只有当堆垛机自动时才继续执行 if (crnProtocol.getModeType() == CrnModeType.AUTO) { //双 if (crnProtocol.getStatusType() == CrnStatusType.SEPARATE_IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getLoaded() == 1 && crnProtocol.getForkPos() == 0) { if (crnProtocol.getStatusTypeTwo() == CrnStatusType.SEPARATE_IDLE && crnProtocol.getTaskNoTwo() == 0 && crnProtocol.getLoadedTwo() == 1 && crnProtocol.getForkPosTwo() == 0){ List wrkMastSplitTwinList1 = wrkMastSplitTwinService.getWrkMastSplitTwin(crn.getId(),1,2,2,0); List wrkMastSplitTwinList2 = wrkMastSplitTwinService.getWrkMastSplitTwin(crn.getId(),2,2,2,0); if (!wrkMastSplitTwinList1.isEmpty() && !wrkMastSplitTwinList2.isEmpty() ){ if (wrkMastSplitTwinList1.size()>1 || wrkMastSplitTwinList2.size()>1 ){ log.error("Pair堆垛机出入库下发异常,堆垛机号={},异常信息={},工位号={},工作类型={}",crn.getId(),"存在多笔可执行作业，请删除无效作业！！！",sign[1],sign[0]); return false; } WrkMastSplitTwin wrkMastSplitTwin1 = wrkMastSplitTwinList1.get(0); WrkMastSplitTwin wrkMastSplitTwin2 = wrkMastSplitTwinList2.get(0); boolean ack = crnExecutePutFullPair(crn.getId(), wrkMastSplitTwin1,wrkMastSplitTwin2, sign[1]); if (ack){ wrkMastSplitTwin1.setWrkSts(wrkMastSplitTwin1.getWrkType()==1? 1:3); wrkMastSplitTwinService.updateById(wrkMastSplitTwin1); wrkMastSplitTwin2.setWrkSts(wrkMastSplitTwin2.getWrkType()==1? 1:3); wrkMastSplitTwinService.updateById(wrkMastSplitTwin2); }else { log.error("堆垛机出入库下发报错,堆垛机号={},异常信息={}",crn.getId(),"下发任务返回值为："+ack); } return false; } } } // 只有当堆垛机工位1取货或者有物 并且 工位2无任务时才继续执行 switch (i){ case 1: if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) { sign[0] = 1; sign[1] = 1; } break; case 2: if (crnProtocol.getStatusType() == CrnStatusType.SEPARATE_IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getLoaded() == 1 && crnProtocol.getForkPos() == 0) { sign[0] = 2; sign[1] = 1; } break; case 3: if (crnProtocol.getStatusTypeTwo() == CrnStatusType.IDLE && crnProtocol.getTaskNoTwo() == 0 && crnProtocol.getLoadedTwo() == 0 && crnProtocol.getForkPosTwo() == 0){ sign[0] = 1; sign[1] = 2; } break; case 4: if (crnProtocol.getStatusTypeTwo() == CrnStatusType.SEPARATE_IDLE && crnProtocol.getTaskNoTwo() == 0 && crnProtocol.getLoadedTwo() == 1 && crnProtocol.getForkPosTwo() == 0){ sign[0] = 2; sign[1] = 2; } break; default: } } if (sign[0]!=0){ List wrkMastSplitTwinList = wrkMastSplitTwinService.getWrkMastSplitTwin(crn.getId(),sign[1],null,sign[0],0); if (wrkMastSplitTwinList.size()>1){ log.error("堆垛机出入库下发异常,堆垛机号={},异常信息={},工位号={},工作类型={}",crn.getId(),"存在多笔可执行作业，请删除无效作业！！！",sign[1],sign[0]); return false; } for (WrkMastSplitTwin wrkMastSplitTwin:wrkMastSplitTwinList){ boolean ack = sign[0] == 1 ? crnExecuteTakeFull(crn.getId(), wrkMastSplitTwin, sign[1]) : crnExecutePutFull(crn.getId(), wrkMastSplitTwin, sign[1]); if (ack){ wrkMastSplitTwin.setWrkSts(wrkMastSplitTwin.getWrkType()==1? 1:3); wrkMastSplitTwinService.updateById(wrkMastSplitTwin); }else { log.error("堆垛机出入库下发报错,堆垛机号={},异常信息={}",crn.getId(),"下发任务返回值为："+ack); } } } }catch (Exception e){ log.error("堆垛机出入库下发报错,堆垛机号={},异常信息={}",crn.getId(),e.getMessage()); } return false; } /* * 堆垛机取货至工位任务 * */ public synchronized boolean crnExecuteTakeFull(Integer crnNo,WrkMastSplitTwin wrkMastSplitTwin, Integer crnStation){ try{ // 命令下发区 -------------------------------------------------------------------------- // 1.堆垛机开始移动 CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(crnNo); // 堆垛机编号 crnCommand.setTaskNo(wrkMastSplitTwin.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommand.setSourcePosX(wrkMastSplitTwin.getStartRow().shortValue()); // 源库位排 crnCommand.setSourcePosY(wrkMastSplitTwin.getStartBay().shortValue()); // 源库位列 crnCommand.setSourcePosZ(wrkMastSplitTwin.getStartLev().shortValue()); // 源库位层 crnCommand.setDestinationPosX((short)0); // 目标库位排 crnCommand.setDestinationPosY((short)0); // 目标库位列 crnCommand.setDestinationPosZ((short)0); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, wrkMastSplitTwin.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMastSplitTwin.getCrnNo(), JSON.toJSONString(crnCommand)); return false; } else { return true; } }catch (Exception e){ return false; } } /* * 堆垛机放货货至出库站点任务 * */ public synchronized boolean crnExecutePutFull(Integer crnNo,WrkMastSplitTwin wrkMastSplitTwin, Integer crnStation){ try{ // 命令下发区 -------------------------------------------------------------------------- // 1.堆垛机开始移动 CrnCommand crnCommand = new CrnCommand(); crnCommand.setCrnNo(crnNo); // 堆垛机编号 crnCommand.setTaskNo(wrkMastSplitTwin.getWrkNo().shortValue()); // 工作号 crnCommand.setAckFinish((short) 0); // 任务完成确认位 crnCommand.setTaskMode(CrnTaskModeType.SEPARATE_PUT); // 任务模式: 单放货 crnCommand.setSourcePosX((short)0); // 源库位排 crnCommand.setSourcePosY((short)0); // 源库位列 crnCommand.setSourcePosZ((short)0); // 源库位层 crnCommand.setDestinationPosX(wrkMastSplitTwin.getEndRow().shortValue()); // 目标库位排 crnCommand.setDestinationPosY(wrkMastSplitTwin.getEndBay().shortValue()); // 目标库位列 crnCommand.setDestinationPosZ(wrkMastSplitTwin.getEndLev().shortValue()); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, wrkMastSplitTwin.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMastSplitTwin.getCrnNo(), JSON.toJSONString(crnCommand)); return false; } else { return true; } }catch (Exception e){ return false; } } /* * 堆垛机取货至工位任务 * */ public synchronized boolean crnExecuteTakeFullPair(Integer crnNo,WrkMastSplitTwin wrkMastSplitTwinOne,WrkMastSplitTwin wrkMastSplitTwinTwo, Integer crnStation){ try{ // 命令下发区 -------------------------------------------------------------------------- // 1.堆垛机开始移动 CrnCommandParam crnCommandParam = new CrnCommandParam(); crnCommandParam.setCrnNo(crnNo); // 堆垛机编号 crnCommandParam.setTaskNo(wrkMastSplitTwinOne.getWrkNo().shortValue()); // 工作号 crnCommandParam.setAckFinish((short) 0); // 任务完成确认位 crnCommandParam.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommandParam.setSourcePosX(wrkMastSplitTwinOne.getStartRow().shortValue()); // 源库位排 crnCommandParam.setSourcePosY(wrkMastSplitTwinOne.getStartBay().shortValue()); // 源库位列 crnCommandParam.setSourcePosZ(wrkMastSplitTwinOne.getStartLev().shortValue()); // 源库位层 crnCommandParam.setDestinationPosX((short)0); // 目标库位排 crnCommandParam.setDestinationPosY((short)0); // 目标库位列 crnCommandParam.setDestinationPosZ((short)0); // 目标库位层 crnCommandParam.setTaskNo2(wrkMastSplitTwinTwo.getWrkNo().shortValue()); // 工作号 crnCommandParam.setAckFinish2((short) 0); // 任务完成确认位 crnCommandParam.setTaskMode2(CrnTaskModeType.SEPARATE_TAKE); // 任务模式: 单取货 crnCommandParam.setSourcePosX2(wrkMastSplitTwinTwo.getStartRow().shortValue()); // 源库位排 crnCommandParam.setSourcePosY2(wrkMastSplitTwinTwo.getStartBay().shortValue()); // 源库位列 crnCommandParam.setSourcePosZ2(wrkMastSplitTwinTwo.getStartLev().shortValue()); // 源库位层 crnCommandParam.setDestinationPosX2((short)0); // 目标库位排 crnCommandParam.setDestinationPosY2((short)0); // 目标库位列 crnCommandParam.setDestinationPosZ2((short)0); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, crnCommandParam.getCrnNo(), new Task(9, crnCommandParam))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnCommandParam.getCrnNo(), JSON.toJSONString(crnCommandParam)); return false; } else { return true; } }catch (Exception e){ return false; } } /* * 堆垛机放货货至出库站点任务 * */ public synchronized boolean crnExecutePutFullPair(Integer crnNo,WrkMastSplitTwin wrkMastSplitTwinOne,WrkMastSplitTwin wrkMastSplitTwinTwo, Integer crnStation){ try{ // 命令下发区 -------------------------------------------------------------------------- // 1.堆垛机开始移动 CrnCommandParam crnCommandParam = new CrnCommandParam(); crnCommandParam.setCrnNo(crnNo); // 堆垛机编号 crnCommandParam.setTaskNo(wrkMastSplitTwinOne.getWrkNo().shortValue()); // 工作号 crnCommandParam.setAckFinish((short) 0); // 任务完成确认位 crnCommandParam.setTaskMode(CrnTaskModeType.SEPARATE_PUT); // 任务模式: 单放货 crnCommandParam.setSourcePosX((short)0); // 源库位排 crnCommandParam.setSourcePosY((short)0); // 源库位列 crnCommandParam.setSourcePosZ((short)0); // 源库位层 crnCommandParam.setDestinationPosX(wrkMastSplitTwinOne.getEndRow().shortValue()); // 目标库位排 crnCommandParam.setDestinationPosY(wrkMastSplitTwinOne.getEndBay().shortValue()); // 目标库位列 crnCommandParam.setDestinationPosZ(wrkMastSplitTwinOne.getEndLev().shortValue()); // 目标库位层 crnCommandParam.setTaskNo2(wrkMastSplitTwinTwo.getWrkNo().shortValue()); // 工作号 crnCommandParam.setAckFinish2((short) 0); // 任务完成确认位 crnCommandParam.setTaskMode2(CrnTaskModeType.SEPARATE_PUT); // 任务模式: 单放货 crnCommandParam.setSourcePosX2((short)0); // 源库位排 crnCommandParam.setSourcePosY2((short)0); // 源库位列 crnCommandParam.setSourcePosZ2((short)0); // 源库位层 crnCommandParam.setDestinationPosX2(wrkMastSplitTwinTwo.getEndRow().shortValue()); // 目标库位排 crnCommandParam.setDestinationPosY2(wrkMastSplitTwinTwo.getEndBay().shortValue()); // 目标库位列 crnCommandParam.setDestinationPosZ2(wrkMastSplitTwinTwo.getEndLev().shortValue()); // 目标库位层 if (!MessageQueue.offer(SlaveType.Crn, crnCommandParam.getCrnNo(), new Task(9, crnCommandParam))) { log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnCommandParam.getCrnNo(), JSON.toJSONString(crnCommandParam)); return false; } else { return true; } }catch (Exception e){ return false; } } /** * Jar任务创建 初始 //完成 */ public synchronized void jarMastGenerate() { for (JarSlave jarSlave : slaveProperties.getJar()) { if (jarSlave.getId()>4){ continue; } try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ continue; } for(JarSlave.StaStn staStn : jarSlave.getJarInSta()){ // 获取硫化罐入库站信息 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, staStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(staStn.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo()!=0){ try{ if (basJarMastService.selectJarMastOperation(jarSlave.getId(),2)!=0){ break; } if (basJarMastService.selectJarMastOperation(jarSlave.getJarOtherId(),3)!=0){ break; } if (basJarMastService.getJarMastByJarIdCount(jarSlave.getId())>=jarMaxLoc*2){ break; } if (basJarMastService.selectJarMastOperation(jarSlave.getId(),0,9)>=jarMaxLoc){ break; } if (!Objects.equals ( basJarMastService.selectJarMastOperation(jarSlave.getId(), 0, 4) , basJarMastService.selectJarMastOperation(jarSlave.getId(), 0, 9) ) ){ break; } BasJarMast jarMastByJarIdMax = basJarMastService.getJarMastByJarIdMax(jarSlave.getId(),0,4); int jarLocDigit = 0; if (Cools.isEmpty(jarMastByJarIdMax)){ if (basJarMastService.selectJarMastOperation(jarSlave.getId(),0,4)!=0){ break; } jarLocDigit = 1; } else if (jarMastByJarIdMax.getJarLocDigit()行={}",4484); if (jarMastGenerateExecute(jarSlave,wrkMast,jarLocDigit,staStn.getStaNo())){ return; } }catch (Exception e){ log.error(jarSlave.getId()+"号硫化罐Jar任务创建异常！"+e); } break; } } } catch (Exception e){ log.error("{}号硫化罐Jar任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } } } /** * Jar任务创建===》执行 //完成 */ public synchronized boolean jarMastGenerateExecute(JarSlave jarSlave,WrkMast wrkMast,Integer jarLocDigit,Integer staNo) { try{ // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } JarThread jarOtherThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getJarOtherId()); JarProtocol jarOtherProtocol = jarOtherThread.getJarProtocol(); if (jarOtherProtocol == null) { return false; } // if (jarOtherProtocol.modeType != JarModeType.AUTO){ // return false; // } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } if (basJar.getJarMode()!=2){ return false; } //自动、空闲、右门关闭、 Other左门关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ if (jarProtocol.statusType != JarStatusType.SOS){ log.error("Jar任务创建===》执行===>行={}",4537); BasJarMast basJarMast = new BasJarMast(basJar, wrkMast, jarLocDigit); basJarMast.setJarEnterStaNo(staNo);//入硫化罐站点 basJarMastService.insert(basJarMast); return true; } } } catch (Exception e){ log.error("{}号硫化罐生成BasJarMast初始任务失败,异常原因={},工作号={},硫化库位={}",jarSlave.getId(),e.getMessage(),wrkMast,jarLocDigit); } return false; } /** * Jar任务完成 //完成 */ public synchronized boolean jarMastGenerateComplete() { try{ for (int[] ex : execute){ try{ WrkMastExecute wrkMastExecuteSou = new WrkMastExecute(); wrkMastExecuteSou.setIoType(ex[0]); wrkMastExecuteSou.setWrkSts(ex[1]); wrkMastExecuteSou.setWrkType(1); List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou); for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ log.error("Jar任务完成===>行={}",4564); if (wrkMastExecute.getIoType()<7 || wrkMastExecute.getIoType()==9){ BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo()); jarMastByWrkNo.setStatus(jarMastByWrkNo.getStatusComplete(wrkMastExecute.getIoType())); if (wrkMastExecute.getIoType()==3 && jarMastByWrkNo.getStatus()==8){ List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarMastByWrkNo.getJarId(), new ArrayList() {{ add(6);//硫化完成 }}); if (basJarMastList.isEmpty()){ continue; } Integer integer = basJarMastService.updateStatus(jarMastByWrkNo.getJarId(), 6, 8); if (basJarMastList.size()!=integer){ log.error("{}号硫化罐硫化完成后开门完成修改硫化档案状态结果数量不一致！！！查询资料数量={}，更新返回数量={}",jarMastByWrkNo.getJarId(),basJarMastList.size(),integer); } } else if (wrkMastExecute.getIoType()==2 && jarMastByWrkNo.getStatus()==5){ List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarMastByWrkNo.getJarId(), new ArrayList() {{ add(4);//硫化完成 }}); if (basJarMastList.isEmpty()){ continue; } Integer integer = basJarMastService.updateStatus(jarMastByWrkNo.getJarId(), 4, 5); if (basJarMastList.size()!=integer){ log.error("{}号硫化罐硫化完成后开门完成修改硫化档案状态结果数量不一致！！！查询资料数量={}，更新返回数量={}",jarMastByWrkNo.getJarId(),basJarMastList.size(),integer); } } else { if (!basJarMastService.updateById(jarMastByWrkNo)){ log.error("硫化区域分段任务完成异常,BasJarMast={},异常信息={}",JSON.toJSONString(jarMastByWrkNo),"更新basJarMast失败"); } } } wrkMastExecute.setWrkSts(wrkMastExecute.getWrkStsComplete()); wrkMastExecute.setWrkType(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化区域分段任务完成异常,wrkMastExecute={},异常信息={}",JSON.toJSONString(wrkMastExecute),"更新wrkMastExecute失败"); } } }catch (Exception e){ log.error("硫化区域分段任务完成异常,execute={},异常信息={}",JSON.toJSONString(ex),e.getMessage()); } } } catch (Exception e){ log.error("硫化区域分段任务完成异常,异常信息={}",e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建 //完成 */ public synchronized void jarWrkMastExecuteGenerate(Integer sign) { try{ boolean[] signExecute = new boolean[]{false,false}; switch (sign){ case 1: case 2: case 3: case 4: signExecute = jarWrkMastExecuteGenerateJar(signExecute,sign);//硫化罐任务 case 5: signExecute = jarWrkMastExecuteGenerateBurial(signExecute, sign);//冷却槽取输送线 default: jarWrkMastExecuteGenerateSte(signExecute,sign);//小车移动 } if (!signExecute[0] && !signExecute[1]){ //Ste移动 jarMastMove(); } } catch (Exception e){ log.error("硫化区域分段任务创建异常,异常信息={}",e.getMessage()); } } public synchronized boolean[] jarWrkMastExecuteGenerateJar(boolean[] signExecute,Integer sign) { for (JarSlave jarSlave : slaveProperties.getJar()) { int i = jarSlave.getId()>2? 1:0; try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ continue; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { continue; } if (jarProtocol.modeType != JarModeType.AUTO){ continue; } JarThread jarOtherThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getJarOtherId()); JarProtocol jarOtherProtocol = jarOtherThread.getJarProtocol(); if (jarOtherProtocol == null) { continue; } // if (jarOtherProtocol.modeType != JarModeType.AUTO){ // continue; // } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); continue; } //门作业 无 //自动、空闲、右门关闭、 Other左门关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ switch (sign){ case 0: case 1: if (jarWrkMastExecuteGenerate1(jarSlave,sign)){ signExecute[i] = true; break;//开门任务 生成入硫化罐任务 } case 2: if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); continue; } if (jarWrkMastExecuteGenerate2(jarSlave,sign)){ signExecute[i] = true; break;//关进料门 } case 3: if (jarWrkMastExecuteGenerate3(jarSlave,sign)){ signExecute[i] = true; break;//开出料门 } case 4: if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); continue; } if (jarWrkMastExecuteGenerate4(jarSlave,sign)){ signExecute[i] = true; break;//出硫化罐 ===》 入冷却槽 } } } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } } return signExecute; } public synchronized boolean[] jarWrkMastExecuteGenerateBurial(boolean[] signExecute,Integer sign) { for (JarSlave jarSlave : slaveProperties.getJar()) { if (jarSlave.getId()<5){ continue; } try{ if (signExecute[jarSlave.getId()-5]){ continue; } if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ signExecute[jarSlave.getId()-5] = true; continue; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { signExecute[jarSlave.getId()-5] = true; continue; } if (jarProtocol.modeType != JarModeType.AUTO){ signExecute[jarSlave.getId()-5] = true; continue; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); continue; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); continue; } //门作业 无 //自动、空闲、右门关闭、 Other左门关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0){ if (jarWrkMastExecuteGenerate5(jarSlave,sign)){ signExecute[jarSlave.getId()-5] = true; return signExecute; //冷却完成上输送线 } continue; } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } } return signExecute; } public synchronized boolean[] jarWrkMastExecuteGenerateSte(boolean[] signExecute,Integer sign) { for (JarSlave jarSlave : slaveProperties.getJar()) { if (jarSlave.getId()<5){ continue; } try{ if (signExecute[jarSlave.getId()-5]){ continue; } if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ continue; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { continue; } if (jarProtocol.modeType != JarModeType.AUTO){ continue; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); continue; } JarThread jarOtherThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getJarOtherId()); JarProtocol jarOtherProtocol = jarOtherThread.getJarProtocol(); if (jarOtherProtocol == null) { continue; } // if (jarOtherProtocol.modeType != JarModeType.AUTO){ // continue; // } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); continue; } //门作业 无 //自动、空闲、右门关闭、 Other左门关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ switch (sign){ case 5: if (jarWrkMastExecuteGenerate5(jarSlave,sign)){ signExecute[jarSlave.getId()-5] = true; break;//出硫化罐 ===》 入冷却槽 } } } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } } return signExecute; } /** * JarWrkMastExecute任务创建 //完成 * 开门任务 * 生成入硫化罐任务 */ public synchronized boolean jarWrkMastExecuteGenerate1(JarSlave jarSlave,Integer sign) { try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ return false; } List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList() {{ add(0); add(2); }}); // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1,SteStatusType.IDLE)){ // return false; // } for (BasJarMast basJarMast : basJarMastList){ JarSlave.StaStn staStn = null; for (JarSlave.StaStn staStn1 : jarSlave.getJarInSta()){ if (staStn1.getStaNo().equals(basJarMast.getJarEnterStaNo())){ staStn = staStn1; } } if (Cools.isEmpty(staStn)){ continue; } //检测站点状态 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, staStn.getDevpPlcId()); StaProtocol staProtocol = devpThread.getStation().get(staStn.getStaNo()); if (staProtocol == null) { continue; } else { staProtocol = staProtocol.clone(); } if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo()==basJarMast.getWrkNo().intValue()){ //检测RGV状态 StaProtocol staProtocolRGV = devpThread.getStation().get(staStn.getRgvNo()); if (staProtocolRGV == null) { continue; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV.rgvBoolean(1)){ // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.WAITING2) || jarProtocol.statusType .equals(JarStatusType.SOS)){ return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); continue; } JarThread jarOtherThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getJarOtherId()); JarProtocol jarOtherProtocol = jarOtherThread.getJarProtocol(); if (jarOtherProtocol == null) { return false; } // if (jarOtherProtocol.modeType != JarModeType.AUTO){ // continue; // } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } if (wrkMastExecuteService.getWrkMastExecuteByjarReginCount(basJar.getRegion())!=0){ return false; } //门作业 无 //自动、空闲、右门关闭、 Other左门关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ if (!jarProtocol.isLeftDoor() && basJarMast.getStatus()==0){ //生成开门任务 OpenTheDoor if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMast,basJar.getJarNo(),new int[]{basJar.getEnterSteNo(),basJar.getEnterRgvNo(),1,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast)); } return true; } else if (jarProtocol.isLeftDoor()){ //生成入硫化罐任务 if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMast,basJar.getJarNo(),new int[]{basJar.getEnterSteNo(),basJar.getEnterRgvNo(),5,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast)); } return true; } // else if (jarProtocol.statusType == JarStatusType.IDLE && jarProtocol.isLeftDoor()){ // log.error("JarWrkMastExecute任务创建===>执行异常===》硫化罐空闲但是门未关===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast)); // } } return false; } else { log.error("JarWrkMastExecute任务创建===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(staProtocolRGV)+";BasJarMast:"+JSON.toJSONString(basJarMast)); return false; } } } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建 //完成 * 关进料门 */ public synchronized boolean jarWrkMastExecuteGenerate2(JarSlave jarSlave,Integer sign) { try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ return false; } List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList() {{ add(4); }}); if (basJarMastList.size() != jarMaxLoc){ return false; } BasJarMast basJarMastSign = basJarMastList.get(0); if (Cools.isEmpty(basJarMastSign)){ return false; } if (wrkMastExecuteService.getWrkMastExecuteByjarReginCount(basJarMastSign.getJarRegin())!=0){ return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1,SteStatusType.IDLE)){ // return false; // } JarSlave.RgvStn rgvStn = jarSlave.getJarInRgv().get(0); if (jarWrkMastExecuteGenerateRgvStatus(rgvStn.getRgvNo(),rgvStn.getDevpPlcId(),1)){ // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.WAITING2) || jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } if (!basJar.getJarCount().equals(jarMaxLoc)){ log.error("{}号硫化罐查询设备库存数异常！！！库存待入数：{}",jarProtocol.getJarNo(),basJar.getJarCount()); return false; } //门作业 无 if (jarProtocol.isAutoing() && jarProtocol.statusType != JarStatusType.SOS && jarProtocol.jarErr==0 && jarProtocol.isRightDoor() && jarProtocol.isLeftDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ //关进料门 if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMastSign,basJar.getJarNo(),new int[]{basJar.getEnterSteNo(),basJar.getEnterRgvNo(),2,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMastSign)); } return true; } return false; } else { log.error("JarWrkMastExecute任务创建===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(rgvStn)+";BasJarMast:"+JSON.toJSONString(basJarMastSign)); return false; } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建 //完成 * 开出料门 */ public synchronized boolean jarWrkMastExecuteGenerate3(JarSlave jarSlave,Integer sign) { try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ return false; } List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList() {{ add(6); }}); if (basJarMastList.size() != jarMaxLoc){ return false; } if (basJarMastService.selectJarMastOperation(jarSlave.getJarOtherId(),5)!=0&&(basJarMastService.selectJarMastOperation(jarSlave.getJarOtherId(),5)!=7)){ return false; } BasJarMast basJarMastSign = basJarMastList.get(0); if (Cools.isEmpty(basJarMastSign)){ return false; } if (wrkMastExecuteService.getWrkMastExecuteByjarReginCount(basJarMastSign.getJarRegin())!=0){ return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),2,SteStatusType.IDLE)){ // return false; // } //判断RGV状态 JarSlave.RgvStn rgvStn = jarSlave.getJarOutRgv().get(0); if (jarWrkMastExecuteGenerateRgvStatus(rgvStn.getRgvNo(),rgvStn.getDevpPlcId(),1)){ // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } // if (jarProtocol.getJarTemperature()>jarTemperature){ // log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); // return false; // } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } //门作业 无 if (jarProtocol.isAutoing() && jarProtocol.statusType == JarStatusType.WAITING2 && jarProtocol.jarErr==0 && !jarProtocol.isLeftDoor() && !jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ //开出料门 if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMastSign,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),3,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMastSign)); } return true; } return false; } else { log.error("JarWrkMastExecute任务创建===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(rgvStn)+";BasJarMast:"+JSON.toJSONString(basJarMastSign)); return false; } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建 //完成 * 出硫化罐 ===》 入冷却槽 */ public synchronized boolean jarWrkMastExecuteGenerate4(JarSlave jarSlave,Integer sign) { try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ return false; } List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList() {{ add(8); }}); if (basJarMastList.isEmpty()){ return false; } List basJarMastList10 = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList() {{ add(10); }}); if (basJarMastList10.size()==jarMaxLoc){ return false; } if (basJarMastService.selectJarMastOperation(jarSlave.getJarOtherId(),4)!=0){ return false; } BasJarMast jarMastByJarIdMin = basJarMastService.getJarMastByJarIdMin(jarSlave.getId(),8,8); if (Cools.isEmpty(jarMastByJarIdMin)){ return false; } if (wrkMastExecuteService.getWrkMastExecuteByjarReginCount(jarMastByJarIdMin.getJarRegin())!=0){ return false; } int count = basJarMastService.selectCount(new EntityWrapper().eq("jar_regin", jarMastByJarIdMin.getJarRegin()).lt("status", 17).gt("status", 10)); if (count>0){ return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2,SteStatusType.IDLE)){ // return false; // } //判断RGV状态 JarSlave.RgvStn rgvStn = jarSlave.getJarOutRgv().get(0); if (jarWrkMastExecuteGenerateRgvStatus(rgvStn.getRgvNo(),rgvStn.getDevpPlcId(),1)){ // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } //门作业 无 // if (jarProtocol.isAutoing() && jarProtocol.statusType == JarStatusType.WAITING4 && jarProtocol.jarErr==0 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ //入冷却槽 if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByJarIdMin,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),6,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByJarIdMin)); } jarMastByJarIdMin.setStatus(jarMastByJarIdMin.getStatusComplete()); if (!basJarMastService.updateById(jarMastByJarIdMin)){ log.error("JarWrkMastExecute任务创建===>jarMastByJarIdMin更新失败===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByJarIdMin)); } return true; } return false; } else { log.error("JarWrkMastExecute任务创建===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(rgvStn)+";BasJarMast:"+JSON.toJSONString(jarMastByJarIdMin)); return false; } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建 //完成 * 冷却完成上输送线 */ public synchronized boolean jarWrkMastExecuteGenerate5(JarSlave jarSlave,Integer sign) { try{ if (wrkMastExecuteService.getWrkMastExecuteByJarIdCount(jarSlave.getId())!=0){ return false; } List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusListB(jarSlave.getId(), new ArrayList() {{ add(12);//冷却完成 }}); if (basJarMastList.isEmpty()){ return false; } if (basJarMastService.selectJarMastOperation(jarSlave.getJarOtherId(),6)!=0){ return false; } BasJarMast jarMastByJarIdMin = basJarMastService.getJarMastByJarIdMinB(jarSlave.getId(),12,12); if (Cools.isEmpty(jarMastByJarIdMin)){ return false; } if (wrkMastExecuteService.getWrkMastExecuteByjarReginCount(jarMastByJarIdMin.getJarRegin())!=0){ return false; } // // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),3,SteStatusType.IDLE)){ // return false; // } //判断RGV状态 JarSlave.RgvStn rgvStn = jarSlave.getJarOutRgv().get(0); if (jarWrkMastExecuteGenerateRgvStatus(rgvStn.getRgvNo(),rgvStn.getDevpPlcId(),1)){ // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // 获取硫化罐信息 JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(jarProtocol.getJarNo())); JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol(); if (jarProtocolOther == null) { return false; } if (jarProtocolOther.modeType != JarModeType.AUTO){ return false; } BasJar basJarOther = basJarMapper.selectById(jarProtocolOther.getJarNo()); if (Cools.isEmpty(basJarOther)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo()); return false; } if (!jarProtocolOther.isRightDoor()){ return false; } //门作业 无 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0){ //冷却完成上输送线 if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByJarIdMin,basJar.getBurial(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),9,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByJarIdMin)); } return true; } return false; } else { log.error("JarWrkMastExecute任务创建===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(rgvStn)+";BasJarMast:"+JSON.toJSONString(jarMastByJarIdMin)); return false; } } catch (Exception e){ log.error("{}号硫化罐JarWrkMastExecute任务创建异常,异常原因={}",jarSlave.getId(),e.getMessage()); } return false; } /** * 判断STE小车状态 //完成 * 1：A面 进料面 * 2：B面 出料面 * 3：冷却槽B面 上输送线 */ public synchronized boolean jarWrkMastExecuteGenerateSteStatus(Integer steNo,Integer type,SteStatusType steStatusType,boolean chargeSign) { try{ //判断小车状态 SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo); if (steThread == null) { return false; } SteProtocol steProtocol = steThread.getSteProtocol(); if (steProtocol == null) { return false; } if (steProtocol.getMode() != (short)1) { log.error(steNo + "号小车离线，无法操作"); return false; } if (steProtocol.getChargeStatus()!=0){ log.error(steNo + "号小车在充电，等待...."); return false; } if (steProtocol.getCharge()<31.0F && chargeSign){ log.error(steNo + "号小车当前电量过低，准备充电...当前电量"+steProtocol.getCharge().toString()); return false; } if (!steProtocol.getStatusType().equals(steStatusType)) { log.error(steNo + "号小车状态不是"+JSON.toJSONString(steStatusType)+"，等待...."); return false; } switch (type){ case 1: if (!steProtocol.getLocaType().equals(SteLocaType.POINT20)) { log.error(steNo + "号小车不在A面平移车，无法操作"); return false; } break; case 2: if (!steProtocol.getLocaType().equals(SteLocaType.POINT23)) { log.error(steNo + "号小车不在B面平移车，无法操作"); return false; } break; case 3: if (!steProtocol.getLocaType().equals(SteLocaType.POINT26) && !steProtocol.getLocaType().equals(SteLocaType.POINT25)) { log.error(steNo + "号小车不在水槽B端，无法操作"); return false; } break; default: return false; } return true; } catch (Exception e){ log.error("{}号小车状态判断状态异常,异常原因={}",steNo,e.getMessage()); } return false; } public synchronized boolean jarWrkMastExecuteGenerateSteStatusCharge(Integer steNo,Integer type,SteStatusType steStatusType,boolean chargeSign) { try{ //判断小车状态 SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo); if (steThread == null) { return false; } SteProtocol steProtocol = steThread.getSteProtocol(); if (steProtocol == null) { return false; } if (steProtocol.getMode() != (short)1) { log.error(steNo + "号小车离线，无法操作"); return false; } if (steProtocol.getCharge()<31.0F && chargeSign){ log.error(steNo + "号小车当前电量过低，准备充电...当前电量"+steProtocol.getCharge().toString()); return false; } if (!steProtocol.getStatusType().equals(steStatusType)) { log.error(steNo + "号小车状态不是"+JSON.toJSONString(steStatusType)+"，等待...."); return false; } switch (type){ case 1: if (!steProtocol.getLocaType().equals(SteLocaType.POINT20)) { log.error(steNo + "号小车不在A面平移车，无法操作"); return false; } break; case 2: if (!steProtocol.getLocaType().equals(SteLocaType.POINT23)) { log.error(steNo + "号小车不在B面平移车，无法操作"); return false; } break; case 3: if (!steProtocol.getLocaType().equals(SteLocaType.POINT26) && !steProtocol.getLocaType().equals(SteLocaType.POINT25)) { log.error(steNo + "号小车不在水槽B端，无法操作"); return false; } break; default: return false; } return true; } catch (Exception e){ log.error("{}号小车状态判断状态异常,异常原因={}",steNo,e.getMessage()); } return false; } /* * 判断RGV小车状态 //完成 * RGV1;//小车无货空闲 * RGV2;//小车输送线取货到位 * RGV3;//小车运行中 * RGV3;//小车运行中 * RGV4;//小车改左侧货物目标站 取1（左）货物 * RGV5;//小车改右侧货物目标站 取2（右）货物 * RGV6;//上位机清除平移车资料 * */ public synchronized boolean jarWrkMastExecuteGenerateRgvStatus(Integer rgvNo,Integer rgvPlcId,Integer type) { try{ //检测RGV状态 DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvPlcId); StaProtocol staProtocolRGV = devpThread.getStation().get(rgvNo); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } return staProtocolRGV.rgvBoolean(type); } catch (Exception e){ log.error("{}号RGV状态判断状态异常,异常原因={}",rgvNo,e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建===>执行 //完成 */ public synchronized boolean jarWrkMastExecuteGenerateExecute(BasJar basJar,BasJarMast basJarMast,Integer id,int[] digit) { try { WrkMastExecute wrkMastExecute = new WrkMastExecute(basJarMast); wrkMastExecute.setJarId(id); wrkMastExecute.setSteId(digit[0]);//穿梭板ID wrkMastExecute.setRgvId(basJar.getEnterRgvNo());//RGV ID enter wrkMastExecute.setRgvEndId(basJar.getOutRgvNo());//RGV ID out wrkMastExecute.setIoType(digit[2]);//任务类型 0: 未知 1: 开进料门 2: 关进料门 3: 开出料门 4: 关出料门 5: 入硫化罐 6: 入冷却槽 7: 穿梭车进冷却槽 8: 穿梭车离开冷却槽 9: 出冷却槽 10：A=>B 11:B=>A 100:小车充电任务 wrkMastExecute.setType(digit[3]);//设备 0: 未知 1: 硫化罐 2: 冷却槽 3: 硫化罐==>冷却槽 return wrkMastExecuteService.insert(wrkMastExecute); } catch (Exception e) { log.error("JarWrkMastExecute任务创建===>执行异常===》异常原因："+e.getMessage()); } return false; } /** * JarWrkMastExecute任务创建===>执行 //完成 */ public synchronized boolean jarWrkMastExecuteGenerateExecuteMove(BasJar basJar,BasJarMast basJarMast,Integer id,int[] digit) { try { WrkMastExecute wrkMastExecute = new WrkMastExecute(basJarMast); wrkMastExecute.setJarId(id); wrkMastExecute.setSteId(digit[0]);//穿梭板ID wrkMastExecute.setRgvId(basJar.getEnterRgvNo());//RGV ID enter wrkMastExecute.setRgvEndId(basJar.getOutRgvNo());//RGV ID out wrkMastExecute.setIoType(digit[2]);//任务类型 0: 未知 1: 开进料门 2: 关进料门 3: 开出料门 4: 关出料门 5: 入硫化罐 6: 入冷却槽 7: 穿梭车进冷却槽 8: 穿梭车离开冷却槽 9: 出冷却槽 10：A=>B 11:B=>A wrkMastExecute.setType(digit[3]);//设备 0: 未知 1: 硫化罐 2: 冷却槽 3: 硫化罐==>冷却槽 return wrkMastExecuteService.insert(wrkMastExecute); } catch (Exception e) { log.error("JarWrkMastExecute任务创建===>执行异常===》异常原因："+e.getMessage()); } return false; } /* * JarWrkMastExecute任务创建==>下发 * Action * */ public synchronized void jarWrkMastExecuteAction(Integer sign,Integer sign2) { if (sign2==0){ jarWrkMastExecuteActionOne(sign); } else if (sign2 == 1){ jarWrkMastExecuteActionTwo(sign); } else if (sign2 == 2){ jarWrkMastExecuteActionThree(sign); } } public synchronized void jarWrkMastExecuteActionOne(Integer sign) { try{ List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, null,0); for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ if (wrkMastExecute.getWrkSts()!=0){ continue; } /* * 任务类型 0: 未知 * 1: 开进料门 2: 关进料门 3: 开出料门 4: 关出料门 * 5: 入硫化罐 * 6: 入冷却槽 * 7: 穿梭车进冷却槽 8: 穿梭车离开冷却槽 * 9: 出冷却槽 * 10：A=>B 11:B=>A * 100：充电任务 * */ log.error("JarWrkMastExecute任务创建==>下发===>行={}",5326); switch (wrkMastExecute.getIoType()){ case 1://1: 开进料门 case 3://3: 开出料门 if (jarWrkMastExecuteActionExecute1(wrkMastExecute,sign)){ break; } continue; case 2: case 4: if (jarWrkMastExecuteActionExecute2(wrkMastExecute,sign)){ break; } continue; case 5: if (jarWrkMastExecuteActionExecute5(wrkMastExecute,sign)){ break; } continue; case 6: if (jarWrkMastExecuteActionExecute6(wrkMastExecute,sign)){ break; } continue; case 7: case 8: if (jarWrkMastExecuteActionExecute7(wrkMastExecute,sign)){ break; } continue; case 9: if (jarWrkMastExecuteActionExecute9(wrkMastExecute,sign)){ break; } continue; case 10: case 11: if (jarWrkMastExecuteActionExecute10(wrkMastExecute,sign)){ break; } continue; case 100: if (jarWrkMastExecuteActionExecute100(wrkMastExecute,sign)){ break; } continue; } } } catch (Exception e){ log.error("JarWrkMastExecute任务创建===>Action==>下发"+e.getMessage()); } } /* * JarWrkMastExecute任务创建==>下发 * Action * */ public synchronized void jarWrkMastExecuteActionTwo(Integer sign) { try{ List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, null,2); for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ /* * 任务类型 0: 未知 * 1: 开进料门 2: 关进料门 3: 开出料门 4: 关出料门 * 5: 入硫化罐 * 6: 入冷却槽 * 7: 穿梭车进冷却槽 8: 穿梭车离开冷却槽 * 9: 出冷却槽 * 10：A=>B 11:B=>A * */ switch (wrkMastExecute.getIoType()){ case 1://1: 开进料门 case 3://3: 开出料门 if (jarWrkMastExecuteActionExecute1(wrkMastExecute,sign)){ break; } return; case 2: case 4: if (jarWrkMastExecuteActionExecute2(wrkMastExecute,sign)){ break; } return; case 5: if (jarWrkMastExecuteActionExecute5(wrkMastExecute,sign)){ break; } return; case 6: if (jarWrkMastExecuteActionExecute6(wrkMastExecute,sign)){ break; } return; case 7: case 8: if (jarWrkMastExecuteActionExecute7(wrkMastExecute,sign)){ break; } return; case 9: if (jarWrkMastExecuteActionExecute9Two(wrkMastExecute,sign)){ break; } return; case 10: case 11: if (jarWrkMastExecuteActionExecute10(wrkMastExecute,sign)){ break; } return; } } } catch (Exception e){ log.error("JarWrkMastExecute任务创建===>Action==>下发"+e.getMessage()); } } /* * JarWrkMastExecute任务创建==>下发 * Action * */ public synchronized void jarWrkMastExecuteActionThree(Integer sign) { try{ List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, null,4); for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ /* * 任务类型 0: 未知 * 1: 开进料门 2: 关进料门 3: 开出料门 4: 关出料门 * 5: 入硫化罐 * 6: 入冷却槽 * 7: 穿梭车进冷却槽 8: 穿梭车离开冷却槽 * 9: 出冷却槽 * 10：A=>B 11:B=>A * */ switch (wrkMastExecute.getIoType()){ case 5: if (jarWrkMastExecuteActionExecute5Three(wrkMastExecute,sign)){ break; } return; case 6: if (jarWrkMastExecuteActionExecute6Three(wrkMastExecute,sign)){ break; } return; } } } catch (Exception e){ log.error("JarWrkMastExecute任务创建===>Action==>下发"+e.getMessage()); } } /** * JarWrkMastExecute任务==>下发 //完成 * 1、3开进料门 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute1(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId()); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getIoType().equals(wrkMastExecute.getIoType()) || !wrkMastExecuteByJarNo.get(0).getWrkSts().equals(wrkMastExecute.getWrkSts()) || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo()) ){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } // if (jarProtocol.getJarTemperature()>jarTemperature){ // log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); // return false; // } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 进料们关闭需打开 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ log.error("1、3开进料门==>任务下发===>行={}",5546); if (!jarProtocol.isLeftDoor() && !jarProtocol.isRightDoor()){ if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else { //直接开门/关门 if (!jarDoorTake(wrkMastExecute,JarTaskModeType.OPEN_THE_DOOR)){ log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } }else if (jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()){ //直接完成 wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 2、4:关进料门 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute2(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId()); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getIoType().equals(wrkMastExecute.getIoType()) || !wrkMastExecuteByJarNo.get(0).getWrkSts().equals(wrkMastExecute.getWrkSts()) || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo()) ){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.WAITING2) || jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 进料们打开需关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ log.error("2、4:关门==>任务下发===>行={}",5667); if (jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()){ if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else { //直接关门 if (!jarDoorTake(wrkMastExecute,JarTaskModeType.CLOSE_THE_DOOR)){ log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } } else if (!jarProtocol.isLeftDoor() && !jarProtocol.isRightDoor()){ //直接完成 wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 5:入硫化罐 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute5(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId()); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getIoType().equals(wrkMastExecute.getIoType()) || !wrkMastExecuteByJarNo.get(0).getWrkSts().equals(wrkMastExecute.getWrkSts()) || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo()) ){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.WAITING2) || jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 进料们打开需关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ log.error("5:入硫化罐==>任务下发===>行={}",5667); //判断小车状态 //入硫化罐小车可临时屏蔽 if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,true)){ return false; } if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){ //调车 == > 取货 if (!jarRgvGetTake(wrkMastExecute ,SteAndJarUtil.getRgvStaRow(wrkMastExecute.getJarEnterStaNo())==1 ,SteAndJarUtil.getRgvStaRow(wrkMastExecute.getJarEnterStaNo())==3)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); return true; } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else { //调车 == > endRow if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * io_type==>5:入硫化罐 : wrkSts ==>4：rgv取货完成 * =====>wrkSts ==>5：Ste穿梭版入硫化罐(清楚RGV资料) * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute5Three(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecute); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.WAITING2) || jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(2) && staProtocolRGVOther.rgvBoolean(1)){//临时 // if (staProtocolRGV.rgvBoolean(2)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 进料们打开需关闭 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ log.error("io_type==>5:入硫化罐 : wrkSts ==>4：rgv取货完成==>任务下发===>行={}",5898); if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){ //判断小车状态 if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,true)){ return false; } //调车 == > 取货 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT22.id,SteTaskModeType.STE_WFFH_13,false,wrkMastExecute.getJarId())){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(5); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else { //调车 == > endRow if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 6:入冷却槽 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute6(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId()); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getIoType().equals(wrkMastExecute.getIoType()) || !wrkMastExecuteByJarNo.get(0).getWrkSts().equals(wrkMastExecute.getWrkSts()) || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo()) ){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // 获取硫化罐信息 JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(wrkMastExecute.getJarId())); JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol(); if (jarProtocolOther == null) { return false; } if (jarProtocolOther.modeType != JarModeType.AUTO){ return false; } BasJar basJarOther = basJarMapper.selectById(jarProtocolOther.getJarNo()); if (Cools.isEmpty(basJarOther)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo()); return false; } if (!jarProtocolOther.isRightDoor()){ return false; } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ //临时 // if ( staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ log.error("6:入冷却槽==>任务下发===>行={}",6002); //判断小车状态 if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,true)){ return false; } if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){ //调车 == > 取货 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT21.id,SteTaskModeType.STE_WFQH_12,false,wrkMastExecute.getJarId())){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else { //调车 == > endRow if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 6:入冷却槽 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute6Three(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecute); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // 获取硫化罐信息 JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(wrkMastExecute.getJarId())); JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol(); if (jarProtocolOther == null) { return false; } if (jarProtocolOther.modeType != JarModeType.AUTO){ return false; } BasJar basJarOther = basJarMapper.selectById(jarProtocolOther.getJarNo()); if (Cools.isEmpty(basJarOther)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo()); return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ //临时 // if (staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0){ log.error("6:入冷却槽 Three==>任务下发===>行={}",6115); if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocolOther.getJarNo())){ //判断小车状态 if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.WAITING2,false)){ return false; } //调车 == > 取货 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT25.id,SteTaskModeType.STE_WFFH_13,false,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(5); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else { //调车 == > endRow if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getJarNoEndRow(basJar.getBurial()))){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } // wrkMastExecute.setWrkType(1); // wrkMastExecute.setWrkSts(2); // if (!wrkMastExecuteService.updateById(wrkMastExecute)){ // log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", // wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); // } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 7：穿梭车进冷却槽 7 B=>C * 8：穿梭车离开冷却槽 8 C=>B * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute7(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecute); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // 获取硫化罐信息 JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(wrkMastExecute.getJarId())); JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol(); if (jarProtocolOther == null) { return false; } if (jarProtocolOther.modeType != JarModeType.AUTO){ return false; } BasJar basJarOther = basJarMapper.selectById(jarProtocolOther.getJarNo()); if (Cools.isEmpty(basJarOther)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo()); return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0 && jarProtocolOther.isLeftDoor() && jarProtocolOther.isRightDoor() ){ log.error("7：穿梭车进冷却槽 7 B=>C//8：穿梭车离开冷却槽 8 C=>B Three==>任务下发===>行={}",6245); if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocolOther.getJarNo())){ //判断小车状态 if (wrkMastExecute.getIoType()==7){ //7 B=>C if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,true)){ //调车 == > 移动 if (jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT26.id,SteTaskModeType.STE_MOVE_14,false,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE,false)){ wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } } else { //8 C=>B if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE,false)){ //调车 == > 移动 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT26.id,SteLocaType.POINT23.id,SteTaskModeType.STE_MOVE_14,false,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,false)){ wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } } } else { //调车 == > endRow if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(jarProtocolOther.getJarNo()))){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 9：出冷却槽 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute9(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId()); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getIoType().equals(wrkMastExecute.getIoType()) || !wrkMastExecuteByJarNo.get(0).getWrkSts().equals(wrkMastExecute.getWrkSts()) || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo()) ){ return false; } // // 获取硫化罐信息 // JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); // JarProtocol jarProtocol = jarThread.getJarProtocol(); // if (jarProtocol == null) { // return false; // } // if (jarProtocol.modeType != JarModeType.AUTO){ // return false; // } // if (jarProtocol.getJarTemperature()>jarTemperature){ // log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); // return false; // } BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号冷却槽查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } // // 获取硫化罐信息 // JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(wrkMastExecute.getJarId())); // JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol(); // if (jarProtocolOther == null) { // return false; // } // if (jarProtocolOther.modeType != JarModeType.AUTO){ // return false; // } // // BasJar basJarOther = basJarMapper.selectByJarNo(jarProtocolOther.getJarNo()); // if (Cools.isEmpty(basJarOther)){ // log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo()); // return false; // } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } // DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocol = devpThread.getStation().get(basJar.getStaNo()); if (staProtocol == null) { return false; } else { staProtocol = staProtocol.clone(); } if (staProtocol == null) { return false; } if (staProtocol.getWorkNo()!=0 || !staProtocol.isAutoing() || staProtocol.isLoading()){ return false; } // // StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); // if (staProtocolRGVOther == null) { // return false; // } else { // staProtocolRGVOther = staProtocolRGVOther.clone(); // } // if (staProtocolRGVOther == null) { // return false; // } // // if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ // if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ // //移走 == > 2 // if (jarRgvTake(wrkMastExecute,2)){ // log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", // wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); // } // return true; // } //门作业 无 //自动、空闲、 // if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() // && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0 // ){ //判断小车状态 if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE,true)){ log.error("9：出冷却槽==>任务下发===>行={}",6410); //调车 == > 取货 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT26.id,SteLocaType.POINT24.id,SteTaskModeType.STE_WFQH_12,false,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},冷却槽数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(basJar),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(1); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},冷却槽数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(basJar),sign); } } return true; // } // return false; // } else { // log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); // return false; // } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 9：出冷却槽 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute9Two(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId()); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getIoType().equals(wrkMastExecute.getIoType()) || !wrkMastExecuteByJarNo.get(0).getWrkSts().equals(wrkMastExecute.getWrkSts()) || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo()) ){ return false; } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocol = devpThread.getStation().get(wrkMastExecute.getJarOutStaNo()); if (staProtocol == null) { return false; } else { staProtocol = staProtocol.clone(); } if (staProtocol == null) { return false; } if (staProtocol.getWorkNo()!=0 || !staProtocol.isAutoing() || !staProtocol.isLoading()){ return false; } //判断STE小车状态 if (jarWrkMastExecuteGenerateSteStatus(wrkMastExecute.getSteId(),3,SteStatusType.IDLE,false)){ log.error("9：出冷却槽Two==>任务下发===>行={}",6468); // 下发站点信息 staProtocol.setWorkNo(wrkMastExecute.getWrkNo().intValue()); staProtocol.setStaNo(wrkMastExecute.getOutStaNo()); if (!MessageQueue.offer(SlaveType.Devp, 2, new Task(2, staProtocol))) { return false; } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("输送线出库目标站命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},放货站点数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(staProtocol),sign); } } return true; } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 10：A=>B\11：B=>A * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute10(WrkMastExecute wrkMastExecute,Integer sign) { try{ List wrkMastExecuteByJarNo = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecute); if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){ return false; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { return false; } if (jarProtocol.modeType != JarModeType.AUTO){ return false; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ log.error("{}号硫化罐查询设备正在硫化中，任务异常！！！",jarProtocol.getJarNo()); return false; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); return false; } // //判断小车状态 // if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){ // return false; // } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo()); if (staProtocolRGVOther == null) { return false; } else { staProtocolRGVOther = staProtocolRGVOther.clone(); } if (staProtocolRGVOther == null) { return false; } if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){ //临时 // if ( staProtocolRGVOther.rgvBoolean(1)){ if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){ //移走 == > 2 if (!jarRgvMoveTake(wrkMastExecute,2)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } return true; } //门作业 无 //自动、空闲、 if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0 ){ log.error("10：A=>B\\11：B=>A==>任务下发===>行={}",6558); if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){ //判断小车状态 if (wrkMastExecute.getIoType()==10){//10：A=>B if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,true)){ //调车 == > 移动 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT23.id,SteTaskModeType.STE_MOVE_14,false,wrkMastExecute.getJarId())){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,false)){ wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } } else {//11:B=>A if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,false)){ //调车 == > 移动 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT20.id,SteTaskModeType.STE_MOVE_14,false,wrkMastExecute.getJarId())){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(3); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,false)){ wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } } } else { //调车 == > endRow if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign); } } return true; } return false; } else { log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute)); return false; } } catch (Exception e){ log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /** * JarWrkMastExecute任务==>下发 //完成 * 100：充电任务 * 任务下发 */ public synchronized boolean jarWrkMastExecuteActionExecute100(WrkMastExecute wrkMastExecute,Integer sign) { try{ // 获取硫化罐信息 BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo()); if (staProtocolRGV == null) { return false; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { return false; } if (staProtocolRGV.rgvBoolean(1) || staProtocolRGV.rgvBoolean(2)){ //门作业 无 //自动、空闲、 log.error("100:充电任务==>任务下发===>行={}",6899); //判断小车状态 if (!jarWrkMastExecuteGenerateSteStatusCharge(basJar.getEnterSteNo(),1,SteStatusType.IDLE,false)){ return false; } //调车 == > 取货 if (!jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT20.id,SteTaskModeType.START_CHARGE,false,wrkMastExecute.getJarId())){ log.error("穿梭板Ste充电命令下发失败，ste号={},任务数据={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute)); } wrkMastExecute.setWrkType(1); wrkMastExecute.setWrkSts(99); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭板Ste充电命令下发失败===>更新wrkMastExecute失败，ste号={},任务数据={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute)); } return true; } return false; } catch (Exception e){ log.error("穿梭板Ste充电命令下发失败,异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage()); } return false; } /* * Rgv 动作 移动 * */ public synchronized boolean jarRgvMoveTake(WrkMastExecute wrkMastExecute,Integer endRow){ try { StaProtocol staProtocol = new StaProtocol(); staProtocol.setSiteId(wrkMastExecute.getRgvId()); staProtocol.setEndRow(endRow.shortValue()); // 下发站点信息 if (!MessageQueue.offer(SlaveType.Devp, 2, new Task(9, staProtocol))) { log.error("平衡车Rgv命令下发失败，堆垛机号={},任务数据={},下发数据={}", wrkMastExecute.getRgvId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocol)); return false; } return true; }catch (Exception e){ log.error("平衡车Rgv命令下发失败，Rgv号={},任务数据={},endRow={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(endRow)); } return false; } /* * Rgv 动作 取货 * */ public synchronized boolean jarRgvGetTake(WrkMastExecute wrkMastExecute,boolean RGV4,boolean RGV5){ try { StaProtocol staProtocol = new StaProtocol(); staProtocol.setSiteId(wrkMastExecute.getRgvId()); staProtocol.setRGV4(RGV4); staProtocol.setRGV5(RGV5); // 下发站点信息 if (!MessageQueue.offer(SlaveType.Devp, 2, new Task(10, staProtocol))) { log.error("平衡车Rgv命令下发失败，堆垛机号={},任务数据={},下发数据={}", wrkMastExecute.getRgvId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocol)); return false; } return true; }catch (Exception e){ log.error("平衡车Rgv命令下发失败，Rgv号={},任务数据={},RGV4={},RGV5={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(RGV4), JSON.toJSON(RGV5)); } return false; } /* * Rgv 动作 取货完成复位 * */ public synchronized boolean jarRgvGetFuTake(WrkMastExecute wrkMastExecute,boolean RGV6){ try { StaProtocol staProtocol = new StaProtocol(); staProtocol.setSiteId(wrkMastExecute.getRgvId()); staProtocol.setRGV6(RGV6); // 下发站点信息 if (!MessageQueue.offer(SlaveType.Devp, 2, new Task(11, staProtocol))) { log.error("平衡车Rgv命令下发失败，堆垛机号={},任务数据={},下发数据={}", wrkMastExecute.getRgvId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocol)); return false; } return true; }catch (Exception e){ log.error("平衡车Rgv命令下发失败，Rgv号={},任务数据={},RGV6={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(RGV6)); } return false; } /* * Ste 动作 * */ public synchronized boolean jarSteTake(WrkMastExecute wrkMastExecute,Integer startLoad,Integer endLoad,SteTaskModeType steTaskModeType,boolean complete,Integer siteId){ try { SteCommand steCommand = new SteCommand(); steCommand.setTaskNo(wrkMastExecute.getWrkNo().intValue()); steCommand.setSteNo(wrkMastExecute.getSteId()); steCommand.setStartLoad(startLoad); steCommand.setEndLoad(endLoad); steCommand.setTaskModeType(steTaskModeType); steCommand.setComplete(complete); if (!complete){ steCommand.setTaskMode(steTaskModeType.id.shortValue()); } steCommand.setJarNo(siteId.shortValue()); if (!MessageQueue.offer(SlaveType.Ste, steCommand.getSteNo(), new Task(2, steCommand))) { log.error("穿梭车Ste命令下发失败，堆垛机号={},任务数据={},下发数据={},complete={}", steCommand.getSteNo(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steCommand),complete); return false; } return true; }catch (Exception e){ log.error("穿梭车Ste命令下发失败，堆垛机号={},任务数据={},complete={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(complete)); } return false; } /* * Jar 动作 * */ public synchronized boolean jarDoorTake(WrkMastExecute wrkMastExecute,JarTaskModeType jarTaskModeType){ try{ JarCommand jarCommand = new JarCommand(); jarCommand.setJarNo(wrkMastExecute.getJarId()); jarCommand.setTaskModeType(jarTaskModeType); if (!MessageQueue.offer(SlaveType.Jar, jarCommand.getJarNo(), new Task(2, jarCommand))) { log.error("硫化罐Jar命令下发失败，堆垛机号={},任务数据={},下发数据={}", jarCommand.getJarNo(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarCommand)); return false; } return true; }catch (Exception e){ log.error("硫化罐Jar命令下发失败，堆垛机号={},任务数据={},下发数据={}", wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarTaskModeType)); } return false; } /** * JarWrkMastExecute任务完成 //完成 */ public synchronized void jarWrkMastExecuteGenerateComplete(Integer sign) { try{ switch (sign){ case 1: case 5: case 9: if (jarWrkMastExecuteGenerateSteComplete(sign)){ break; } case 2: case 6: case 10: if (jarWrkMastExecuteGenerateJarComplete(sign)){ break; } case 3: case 7: case 11: if (jarWrkMastExecuteGenerateRgvComplete1(sign)){ break; } case 4: case 8: case 12: if (jarWrkMastExecuteGenerateRgvComplete2(sign)){ break; } default: return; } }catch (Exception e){ log.error("JarWrkMastExecute任务完成报错！"+e); } } /** * JarWrkMastExecute任务完成 ===>Ste //完成 */ public synchronized boolean jarWrkMastExecuteGenerateSteComplete(Integer sign) { try{ for (SteSlave steSlave : slaveProperties.getSte()) { SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId()); if (steThread == null) { continue; } SteProtocol steProtocol = steThread.getSteProtocol(); if (steProtocol == null) { continue; } if (steProtocol.getMode()==(short)1 && steProtocol.taskNo!=0 && steProtocol.getChargeStatus()==0){ // if (steProtocol.statusType.equals(SteStatusType.WAITING)){ // // } List wrkMastExecuteByWrkNoList = wrkMastExecuteService.getWrkMastExecuteByWrkNoList(steProtocol.getTaskNo().longValue()); for (WrkMastExecute wrkMastExecute : wrkMastExecuteByWrkNoList){ if (!Cools.isEmpty(wrkMastExecute)){ switch (wrkMastExecute.getIoType()){ case 6: if (wrkMastExecute.getWrkSts()==3){//==>4 //1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版取货、4：取货完成等待下一步、5：Ste穿梭版放货至冷却池、6：放货完成、7：更新完成 //io_type = 6 //ste任务等待完成 if (steProtocol.statusType.equals(SteStatusType.WAITING)){ //ste任务完成 if (jarSteTake(wrkMastExecute,null,null,null,true,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSON(steProtocol),sign); } return true; } } log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(steProtocol),sign); return true; } case 5: if (wrkMastExecute.getWrkSts()==5){ //1：RGV小车移动、2：RGV小车到位、3：rgv取货、4：rgv取货完成、5：Ste穿梭版入硫化罐、6：入罐完成、7：更新完成 //io_type = 5 //ste任务完成 if (steProtocol.statusType.equals(SteStatusType.WAITING)){ //ste任务完成 if (jarSteTake(wrkMastExecute,null,null,null,true,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ wrkMastExecute.setWrkSts(6); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign); } return true; } } log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign); return true; } continue; case 7: case 8: case 10: case 11: //1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版移动中、4：移动完成、5：更新完成 if (wrkMastExecute.getWrkSts()==3){ //ste任务完成 if (steProtocol.statusType.equals(SteStatusType.WAITING)){ //ste任务完成 if (jarSteTake(wrkMastExecute,null,null,null,true,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign); } return true; } } log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign); return true; } continue; case 9: if (wrkMastExecute.getWrkSts()==1){ //1：Ste穿梭版取放货中、2：放货完成等待下一步、3：输送线任务下发完成、4：更新完成 //io_type = 9 //ste任务完成 if (steProtocol.statusType.equals(SteStatusType.WAITING)){ //ste任务完成 if (jarSteTake(wrkMastExecute,null,null,null,true,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){ wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign); } return true; } } log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign); continue; } default: continue; } } } } } return true; }catch (Exception e){ log.error("JarWrkMastExecute任务完成 ===>Ste报错！"+e); } return false; } /** * JarWrkMastExecute任务完成 ===>Jar //完成 * //硫化完成 修改任务状态 */ public synchronized boolean jarWrkMastExecuteGenerateJarComplete(Integer sign) { try{ for (JarSlave jarSlave : slaveProperties.getJar()) { if (jarSlave.getId()>4){ continue; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { continue; } if (jarProtocol.modeType != JarModeType.AUTO){ continue; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); continue; } //WAITING2(4, "硫化完成"), if (jarProtocol.getJarErr()==0 && jarProtocol.getStatusType().equals(JarStatusType.WAITING2) && !jarProtocol.isRightDoor() && !jarProtocol.isLeftDoor() && jarProtocol.leftDoorOpen==0 && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0 && jarProtocol.rightDoorClose==0 ){ List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList() {{ add(5);//硫化中 }}); if (basJarMastList.isEmpty()){ continue; } Integer integer = basJarMastService.updateStatus(jarProtocol.getJarNo(), 5, 6); if (basJarMastList.size()!=integer){ log.error("{}号硫化罐硫化完成修改硫化档案状态结果数量不一致！！！查询资料数量={}，更新返回数量={}",jarProtocol.getJarNo(),basJarMastList.size(),integer); } } else if (jarProtocol.getJarErr()==0 && jarProtocol.isRightDoor() && jarProtocol.isLeftDoor() && jarProtocol.leftDoorOpen!=1 && jarProtocol.leftDoorOpen!=3 && jarProtocol.rightDoorOpen!=1 && jarProtocol.rightDoorOpen!=3 && (jarProtocol.leftDoorOpen==2 || jarProtocol.rightDoorOpen==2)){ if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } WrkMastExecute wrkMastExecuteSou = new WrkMastExecute(); wrkMastExecuteSou.setWrkSts(3); List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou); if (wrkMastExecuteList.isEmpty()){ WrkMastExecute execute = new WrkMastExecute(); execute.setJarId(jarProtocol.getJarNo()); //直接关门 if (!jarDoorTake(execute,JarTaskModeType.OPEN_THE_DOOR_COMPLETE)){ log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}", execute.getJarId(), JSON.toJSON(execute), JSON.toJSON(jarProtocol),sign); } return true; } for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ if (wrkMastExecute.getIoType() == 1 || wrkMastExecute.getIoType() == 3){ //直接关门 if (!jarDoorTake(wrkMastExecute,JarTaskModeType.OPEN_THE_DOOR_COMPLETE)){ log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign); } wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign); return false; } return true; } } } else if (jarProtocol.getJarErr()==0 && !jarProtocol.isRightDoor() && !jarProtocol.isLeftDoor() && jarProtocol.leftDoorClose!=1 && jarProtocol.leftDoorClose!=3 && jarProtocol.rightDoorClose!=1 && jarProtocol.rightDoorClose!=3 && (jarProtocol.leftDoorClose==2 || jarProtocol.rightDoorClose==2)){ if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); return false; } WrkMastExecute wrkMastExecuteSou = new WrkMastExecute(); wrkMastExecuteSou.setWrkSts(3); List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou); if (wrkMastExecuteList.isEmpty()){ WrkMastExecute execute = new WrkMastExecute(); execute.setJarId(jarProtocol.getJarNo()); //直接关门 if (!jarDoorTake(execute,JarTaskModeType.CLOSE_THE_DOOR_COMPLETE)){ log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}", execute.getJarId(), JSON.toJSON(execute), JSON.toJSON(jarProtocol),sign); } return true; } for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ if (wrkMastExecute.getIoType() == 2 || wrkMastExecute.getIoType() == 4){ //直接关门 if (!jarDoorTake(wrkMastExecute,JarTaskModeType.CLOSE_THE_DOOR_COMPLETE)){ log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign); } wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign); return false; } return true; } } } } return true; }catch (Exception e){ log.error("//硫化完成 修改任务状态 报错！"+e); } return false; } /** * JarWrkMastExecute任务完成 ===>RGV移动 //完成 */ public synchronized boolean jarWrkMastExecuteGenerateRgvComplete1(Integer sign) { try{ WrkMastExecute wrkMastExecuteSou = new WrkMastExecute(); wrkMastExecuteSou.setWrkSts(1); List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou); for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ if (wrkMastExecute.getIoType() == 9){ continue; } DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(wrkMastExecute.getRgvId()); if (staProtocolRGV == null) { continue; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { continue; } StaProtocol staProtocolRGVEnd = devpThread.getStation().get(wrkMastExecute.getRgvEndId()); if (staProtocolRGVEnd == null) { continue; } else { staProtocolRGVEnd = staProtocolRGVEnd.clone(); } if (staProtocolRGVEnd == null) { continue; } if (staProtocolRGV.getNowRow() == staProtocolRGVEnd.getNowRow() && staProtocolRGV.getNowRow() == SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId())){ wrkMastExecute.setWrkSts(2); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},平衡车Rgv数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign); return false; } return true; } } return true; }catch (Exception e){ log.error("JarWrkMastExecute任务完成 ===>RGV移动！异常"+e); } return false; } /** * JarWrkMastExecute任务完成 ===>RGV取货 //完成 */ public synchronized boolean jarWrkMastExecuteGenerateRgvComplete2(Integer sign) { try{ WrkMastExecute wrkMastExecuteSou = new WrkMastExecute(); wrkMastExecuteSou.setWrkSts(3); wrkMastExecuteSou.setIoType(5); List wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou); for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){ DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocolRGV = devpThread.getStation().get(wrkMastExecute.getRgvId()); if (staProtocolRGV == null) { continue; } else { staProtocolRGV = staProtocolRGV.clone(); } if (staProtocolRGV == null) { continue; } if ( staProtocolRGV.rgvBoolean(2) && staProtocolRGV.getNowRow() == SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId())){ //调车 == > 取货完成复位 if (!jarRgvGetFuTake(wrkMastExecute,true)){ log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}", wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign); return true; } wrkMastExecute.setWrkSts(4); if (!wrkMastExecuteService.updateById(wrkMastExecute)){ log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},平衡车Rgv数据={},sign={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign); return true; } return true; } else { log.error("{}号平衡车当前状态不满足入硫化罐条件，当前任务，平衡车从取货"); } } return true; }catch (Exception e){ log.error(" JarWrkMastExecute任务完成 ===>RGV取货 异常！"+e); } return false; } /** * Jar任务 穿梭车移动任务 //完成 */ public synchronized boolean jarMastMove() { try{ for (SteSlave steSlave : slaveProperties.getSte()){ SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId()); if (steThread == null) { continue; } SteProtocol steProtocol = steThread.getSteProtocol(); if (steProtocol == null) { continue; } if (wrkMastExecuteService.selectNoStart(steSlave.getId())!=0){ continue; } if (wrkMastExecuteService.selectMoveStart(steSlave.getId())!=0){ continue; } try{ if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),1,SteStatusType.IDLE,false)){ List wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null,steProtocol.getSteNo().intValue()); List wrkMastExecutes100 = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 100, null,steProtocol.getSteNo().intValue()); if (wrkMastExecutes.isEmpty() && wrkMastExecutes100.isEmpty()){ List wrkMastExecutesB = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null,steProtocol.getSteNo().intValue()); List wrkMastExecutesC = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null,steProtocol.getSteNo().intValue()); if (!wrkMastExecutesB.isEmpty() || !wrkMastExecutesC.isEmpty()){ WrkMastExecute wrkMastExecute = !wrkMastExecutesB.isEmpty() ? wrkMastExecutesB.get(0) : wrkMastExecutesC.get(0); BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo()); //A==>B if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),10,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo)); } continue; } } } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),2,SteStatusType.IDLE,false)){ List wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null,steProtocol.getSteNo().intValue()); if (wrkMastExecutes.isEmpty()){ List wrkMastExecutesA = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null,steProtocol.getSteNo().intValue()); List wrkMastExecutesC = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null,steProtocol.getSteNo().intValue()); List wrkMastExecutes100 = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 100, null,steProtocol.getSteNo().intValue()); if (!wrkMastExecutes100.isEmpty()){ WrkMastExecute wrkMastExecute = wrkMastExecutes100.get(0); BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } BasJarMast jarMastByWrkNo = new BasJarMast(basJar); jarMastByWrkNo.setWrkNo(Integer.toUnsignedLong(wrkMastExecute.getWrkNo().intValue()));//工作号 jarMastByWrkNo.setJarEnterStaNo(basJar.getEnterRgvNo()); jarMastByWrkNo.setEnterStaNo(basJar.getEnterRgvNo()); jarMastByWrkNo.setOutStaNo(basJar.getOutRgvNo()); //B==>A if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),11,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo)); } continue; } if (!wrkMastExecutesA.isEmpty()){ WrkMastExecute wrkMastExecute = wrkMastExecutesA.get(0); BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo()); //B==>A if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),11,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo)); } continue; } if (!wrkMastExecutesC.isEmpty()){ WrkMastExecute wrkMastExecute = wrkMastExecutesC.get(0); BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo()); //B==>C if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),7,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo)); } continue; } } } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),3,SteStatusType.IDLE,false)){ List wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null,steProtocol.getSteNo().intValue()); if (wrkMastExecutes.isEmpty()){ List wrkMastExecutesB = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null,steProtocol.getSteNo().intValue()); List wrkMastExecutesA = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null,steProtocol.getSteNo().intValue()); List wrkMastExecutes100 = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 100, null,steProtocol.getSteNo().intValue()); if (!wrkMastExecutes100.isEmpty()){ WrkMastExecute wrkMastExecute = wrkMastExecutes100.get(0); BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } BasJarMast jarMastByWrkNo = new BasJarMast(basJar); jarMastByWrkNo.setWrkNo(Integer.toUnsignedLong(wrkMastExecute.getWrkNo().intValue()));//工作号 jarMastByWrkNo.setJarEnterStaNo(basJar.getEnterRgvNo()); jarMastByWrkNo.setEnterStaNo(basJar.getEnterRgvNo()); jarMastByWrkNo.setOutStaNo(basJar.getOutRgvNo()); //C==>B if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),8,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo)); } continue; } if (!wrkMastExecutesB.isEmpty() || !wrkMastExecutesA.isEmpty()){ WrkMastExecute wrkMastExecute = !wrkMastExecutesB.isEmpty() ? wrkMastExecutesB.get(0) : wrkMastExecutesA.get(0); BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId()); return false; } BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo()); //C==>B if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),8,1})){ log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo)); } continue; } } } }catch (Exception e){ log.error("硫化区域分段任务完成异常,steProtocol={},异常信息={}",JSON.toJSONString(steProtocol),e.getMessage()); } WrkMastExecute wrkMastExecute = wrkMastExecuteService.selectStart(steSlave.getId()); } } catch (Exception e){ log.error("硫化区域分段任务完成异常,异常信息={}",e.getMessage()); } return false; } /** * ste充电任务创建 //完成 */ public synchronized boolean jarChargeGenerate() { try{ //80%电量 无任务 充电 >50电量 有任务 断电 //30%电量 不接取任务 无进行中任务 充电 >50电量 有任务 断电 for (SteSlave steSlave : slaveProperties.getSte()){ SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId()); if (steThread == null) { continue; } SteProtocol steProtocol = steThread.getSteProtocol(); if (steProtocol == null || steProtocol.getChargeStatus()!=0) { continue; } WrkMastExecute wrkMastExecuteByCharge = wrkMastExecuteService.getWrkMastExecuteByCharge(steSlave.getId()); if (!Cools.isEmpty(wrkMastExecuteByCharge)){ continue; } if (steProtocol.getCharge()<30.0F){ if (wrkMastExecuteService.selectMoveStartCharge(steSlave.getId())!=0){ continue; } } else if (steProtocol.getCharge()<80.0F){ List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusListCharge(steSlave.getId(), new ArrayList() {{ add(5); add(11); add(17); }}); if(!basJarMastList.isEmpty()){ continue; } if (wrkMastExecuteService.selectNoStart(steSlave.getId())!=0){ continue; } if (wrkMastExecuteService.selectMoveStart(steSlave.getId())!=0){ continue; } } else { continue; } try{ boolean jarIDLESign = false; if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),1,SteStatusType.IDLE,false)){ //生成充电任务 //A BasJar basJar = basJarMapper.selectById(steSlave.getId()==1? 1:3); int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(7));//充电工作号 BasJarMast basJarMast = new BasJarMast(basJar); basJarMast.setWrkNo(Integer.toUnsignedLong(workNo));//工作号 basJarMast.setJarEnterStaNo(basJar.getEnterRgvNo()); basJarMast.setEnterStaNo(basJar.getEnterRgvNo()); basJarMast.setOutStaNo(basJar.getOutRgvNo()); if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMast,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),100,1})){ log.error("JarWrkMastExecute充电任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast)); } continue; } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),2,SteStatusType.IDLE,false)){ jarIDLESign =true; } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),3,SteStatusType.IDLE,false)){ jarIDLESign =true; } if (jarIDLESign){ //生成充电任务 //C==>A BasJar basJar = null; List basJarList = basJarMapper.selectList(new EntityWrapper().eq("region", steSlave.getId())); for (BasJar basJarNow : basJarList){ // 获取硫化罐信息0.0 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, basJarNow.getJarNo()); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { continue; } if (jarProtocol.modeType != JarModeType.AUTO){ continue; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ continue; } if (jarProtocol.getJarTemperature()>jarTemperature){ continue; } if (jarProtocol.leftDoorOpen != 0 || jarProtocol.rightDoorOpen != 0){ continue; } basJar = basJarNow; break; } if (basJar == null){ continue; } int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(7));//充电工作号 BasJarMast basJarMast = new BasJarMast(basJar); basJarMast.setWrkNo(Integer.toUnsignedLong(workNo));//工作号 basJarMast.setJarEnterStaNo(basJar.getEnterRgvNo()); basJarMast.setEnterStaNo(basJar.getEnterRgvNo()); basJarMast.setOutStaNo(basJar.getOutRgvNo()); if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMast,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),100,1})){ log.error("JarWrkMastExecute充电任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast)); } } }catch (Exception e){ log.error("充电任务创建异常,steProtocol={},异常信息={}",JSON.toJSONString(steProtocol),e.getMessage()); } } } catch (Exception e){ log.error("硫化区域分段充电任务创建异常,异常信息={}",e.getMessage()); } return false; } /** * Ste充电任务完成 //完成 */ public synchronized boolean jarChargeComplete() { try{ //80%电量 无任务 充电 >50电量 有任务 断电 //30%电量 不接取任务 无进行中任务 充电 >50电量 有任务 断电 for (SteSlave steSlave : slaveProperties.getSte()){ SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId()); if (steThread == null) { continue; } SteProtocol steProtocol = steThread.getSteProtocol(); if (steProtocol == null || steProtocol.getChargeStatus()!=1) { continue; } if (steProtocol.getCharge()>95.0F || steProtocol.getFullCharge()){ } else if (steProtocol.getCharge()>50.0F){ List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusListCharge(steSlave.getId(), new ArrayList() {{ add(5); add(11); add(17); }}); if(basJarMastList.isEmpty()){ if (wrkMastExecuteService.selectNoStartCharge(steSlave.getId())==0){ if (wrkMastExecuteService.selectMoveStart(steSlave.getId())==0){ continue; } } } } else { continue; } WrkMastExecute wrkMastExecuteByCharge = wrkMastExecuteService.getWrkMastExecuteByCharge(steSlave.getId()); if (Cools.isEmpty(wrkMastExecuteByCharge)){ BasJar basJar = basJarMapper.selectById(steSlave.getId()==1? 1:3); int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(7));//充电工作号 BasJarMast basJarMast = new BasJarMast(basJar); basJarMast.setWrkNo(Integer.toUnsignedLong(workNo));//工作号 basJarMast.setJarEnterStaNo(basJar.getEnterRgvNo()); basJarMast.setEnterStaNo(basJar.getEnterRgvNo()); basJarMast.setOutStaNo(basJar.getOutRgvNo()); wrkMastExecuteByCharge = new WrkMastExecute(basJarMast); wrkMastExecuteByCharge.setJarId(basJar.getJarNo()); wrkMastExecuteByCharge.setSteId(steSlave.getId());//穿梭板ID wrkMastExecuteByCharge.setRgvId(basJar.getEnterRgvNo());//RGV ID enter wrkMastExecuteByCharge.setRgvEndId(basJar.getOutRgvNo());//RGV ID out wrkMastExecuteByCharge.setIoType(100);//任务类型 0: 未知 1: 开进料门 2: 关进料门 3: 开出料门 4: 关出料门 5: 入硫化罐 6: 入冷却槽 7: 穿梭车进冷却槽 8: 穿梭车离开冷却槽 9: 出冷却槽 10：A=>B 11:B=>A 100:小车充电任务 wrkMastExecuteByCharge.setType(1);//设备 0: 未知 1: 硫化罐 2: 冷却槽 3: 硫化罐==>冷却槽 } try{ if (jarWrkMastExecuteGenerateSteStatusCharge(steSlave.getId(),1,SteStatusType.CHARGE,true)){ //完成充电任务 //调车 == > 断开充电 if (!jarSteTake(wrkMastExecuteByCharge,SteLocaType.POINT20.id,SteLocaType.POINT20.id,SteTaskModeType.CLOSE_CHARGE,true,wrkMastExecuteByCharge.getJarId())){ log.error("穿梭板Ste命令下发失败，ste号={},任务数据={}", wrkMastExecuteByCharge.getSteId(), JSON.toJSONString(wrkMastExecuteByCharge)); } wrkMastExecuteByCharge.setWrkType(2); wrkMastExecuteByCharge.setWrkSts(100); if (!wrkMastExecuteService.updateById(wrkMastExecuteByCharge)){ log.error("充电任务完成命令下发失败===>更新wrkMastExecute失败，ste号={},任务数据={}", wrkMastExecuteByCharge.getSteId(), JSON.toJSONString(wrkMastExecuteByCharge)); } } }catch (Exception e){ log.error("充电任务完成异常,steProtocol={},异常信息={}",JSON.toJSONString(steProtocol),e.getMessage()); } } } catch (Exception e){ log.error("硫化区域分段任务充电任务完成异常,异常信息={}",e.getMessage()); } return false; } /** * 其他 ===>> 607分配硫化罐 */ public synchronized void stackingCompletionDriveTray() { Integer staNo1 = jarGetStartStaNo(607); if (staNo1!=0){ SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 2); StaProtocol staProtocol607 = devpThread.getStation().get(607); if (staProtocol607.getWorkNo()<9001 && staProtocol607.getWorkNo()!=0 && staProtocol607.isLoading() && staProtocol607.isAutoing() && staProtocol607.getStaNo() == 607){ staProtocol607.setStaNo(staNo1); boolean result2 = MessageQueue.offer(SlaveType.Devp, 2, new Task(5, staProtocol607)); } } } public synchronized Integer jarGetStartStaNo(Integer staNo) { try { int[] jarNos=new int[]{3,1,4,2};//(607分配硫化罐) ArrayList staNos = new ArrayList() {{ add(607);add(608);add(609);add(610);add(611);add(612); add(613);add(614);add(615);add(616);add(617);add(618); add(619);add(620);add(621);add(622); }}; ArrayList jarNoList = new ArrayList<>(); ArrayList jarNoList1 = new ArrayList<>(); ArrayList jarNoListNow = new ArrayList<>(); for (int jarNo : jarNos) { List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarNo, new ArrayList() {{ add(0); add(1); add(2); add(3); add(4); }}); if (basJarMastList.isEmpty()){ continue; } if (basJarMastList.size()>0 && basJarMastList.size() jarMastByJarIdAndStatusList = basJarMastService.getJarMastByJarIdAndStatusList(8, jarNo); if (jarMastByJarIdAndStatusList.isEmpty()){ jarNoList.add(jarNo); } } jarNoList1 = new ArrayList(); for (int jarNo : jarNos) { if (!jarNoList.contains(jarNo)){ jarNoList1.add(jarNo); } } for (int jarNo : jarNoList1) { List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarNo, new ArrayList() {{ add(5); add(6); add(7); add(8); add(9); add(13); add(14); add(15); }}); if (basJarMastList.isEmpty()){ jarNoList.add(jarNo); } } for (int jarNo : jarNoList) { if (jarNoListNow.contains(jarNo)){ continue; } // 获取硫化罐信息 JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarNo); JarProtocol jarProtocol = jarThread.getJarProtocol(); if (jarProtocol == null) { continue; } if (jarProtocol.modeType != JarModeType.AUTO){ continue; } if (jarProtocol.statusType .equals(JarStatusType.SOS)){ continue; } if (jarProtocol.getJarTemperature()>jarTemperature){ log.error("{}号硫化罐查询设备温度过高，等待降温....！！！",jarProtocol.getJarNo()); continue; } BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo()); if (Cools.isEmpty(basJar)){ log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo()); continue; } List basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarNo, new ArrayList() {{ add(0); add(1); add(2); add(3); add(4); }}); DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2); Integer count = basJarMastList.size(); ArrayList wrkNoList = new ArrayList<>(); for (Integer staNoEnt : staNos){ StaProtocol staProtocolEnt = devpThread.getStation().get(staNoEnt); if (staProtocolEnt != null && staProtocolEnt.getWorkNo()!=0 && !wrkNoList.contains(staProtocolEnt.getWorkNo())){ if (staProtocolEnt.getStaNo().equals(basJar.getEntStaNo$())){ count++; wrkNoList.add(staProtocolEnt.getWorkNo()); } } } if (count> 分配硫化罐进入下一步"+e); } return 0; } }