#

lsh

2023-03-09 27c129a348b3daa64a54195f1442748737148057

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -115,59 +115,51 @@
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();
                // 尺寸检测异常
                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(3, errMsg));
                    }
                    continue;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999))
                        && staProtocol.isPakMk()) {

                    // 尺寸检测异常
                    boolean back = false;
                    String errMsg = "";
                    if (staProtocol.isFrontErr()) {
                        errMsg = "前超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "高超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重";
                        back = true;
                    }
                    if (!back && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码失败";
                        back = true;
                    }

                    // 退回
                    if (back) {
                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                        staProtocol.setWorkNo((short) 32002);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        // led 异常显示
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                        if (ledThread != null) {
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
                        }
                        continue;
                    }

                    // 获取条码扫描仪信息
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
@@ -177,7 +169,7 @@
                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
//                        News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)|| "00000000".equals(barcode)) {
                            staProtocol.setWorkNo((short) 32002);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
@@ -408,7 +400,6 @@
                    if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) {
                        wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
                        if (null == wrkMast) {
                            News.error("{}任务号错误，暂无拣料任务！", staProtocol.getWorkNo());
                            continue;
                        }
                    } else {
@@ -727,6 +718,51 @@
                continue;
            }

            List<LocMast> locMasts = null;
            boolean sign=false;
            if (locMast.getRow1()>=5){
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
                        .eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>locMast.getRow1()){
                        if (!locMast1.getLocSts().equals("F")){
                            if (!locMast1.getLocSts().equals("X")){
                                sign=true;
                                break;
                            }
                        }
                    }else if (locMast1.getRow1()<locMast.getRow1()){
                        if (locMast1.getLocSts().equals("F")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }else {
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
                        .eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>locMast.getRow1()){
                        if (locMast1.getLocSts().equals("F")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }else if (locMast1.getRow1()<locMast.getRow1()){
                        if (!locMast1.getLocSts().equals("F")){
                            if (!locMast1.getLocSts().equals("X")){
                                sign=true;
                                break;
                            }
                        }
                    }
                }
            }
            if (sign){
                continue;
            }

            // 检测是否存在出库任务
            if (null != wrkMastMapper.selectPakout(slave.getId(), null)) {
                News.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
@@ -734,7 +770,9 @@
            }

            // 置顶任务
            wrkMast.setIoPri((double) 9999);
            if (wrkMast.getIoPri()<8000){
                wrkMast.setIoPri(wrkMast.getIoPri()+9000d);
            }
            wrkMastMapper.updateById(wrkMast);

                // 目标库位 ===>> 最外层库位
@@ -900,6 +938,36 @@
                News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                continue;
            }
            List<LocMast> locMasts = null;
            boolean sign=false;
            if (sourceSta.getRow1()>=5){
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
                        .eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()<sourceSta.getRow1()){
                        if (!locMast1.getLocSts().equals("O")){
                            News.error("当前工作档源库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }else {
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
                        .eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>sourceSta.getRow1()){
                        if (!locMast1.getLocSts().equals("O")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }
            if (sign){
                continue;
            }

            // 同库位组进行校验
            List<String> groupLocNo = Utils.getGroupLocNo(wrkMast.getSourceLocNo());
@@ -949,7 +1017,9 @@
                }

                // 置顶任务
                wrkMast.setIoPri((double) 9998);
                if (wrkMast.getIoPri()<8000){
                    wrkMast.setIoPri(wrkMast.getIoPri()+8999d);
                }
                wrkMastMapper.updateById(wrkMast);

                // 最外层库位，直接堆垛机出库
@@ -1614,6 +1684,17 @@
                    WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
                    if (wrkCharge == null) {
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        wrkMast = wrkMastMapper.selectCrnWaiting2(crnProtocol.getTaskNo().intValue());
                        if (wrkMast.getIoType() != 11) {
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                News.error("堆垛机处于等待确认且任务完成状态,复位，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                            } else {
                                News.error("堆垛机处于等待确认且任务完成状态,复位失败，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                            }
                        }
                        continue;
                    } else {
                        // 小车搬至指定库位完成
@@ -2385,18 +2466,11 @@
                        break;
                }
                ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
                ledCommand.setLocNo(wrkMast.getLocNo());
                ledCommand.setStaNo(wrkMast.getStaNo());
                if (wrkMast.getIoType() != 110) {
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    try {
                        WrkDetl wrkDetl = wrkDetls.get(0);
                        if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                            OrderDetl orderDetl = orderDetlMapper.selectItemNoneOfBatch(wrkDetl.getOrderNo(), wrkDetl.getMatnr());
                            ledCommand.getMatDtos().add(new MatDto(orderDetl));
                        }
                    } catch (Exception e) {
                        News.error("led execute fail", e);
                    }
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(),wrkDetl.getSpecs())));
                }
                commands.add(ledCommand);
            }
@@ -2409,9 +2483,20 @@
            }
            // 命令下发 -------------------------------------------------------------------------------
            if (!commands.isEmpty()) {
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    continue;
                if (led.getId()>3){
                    if (!MessageQueue.offer(SlaveType.Led, led.getId()-3, new Task(1, commands))) {
                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId()-3, 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);
                    }
                }
            }

@@ -2441,6 +2526,35 @@
     */
    public 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()) {
                ledThread.setLedMk(true);
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(4, new ArrayList<>()))) {
                    News.error(" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                } else {

                }
            }
        }
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
            // 命令集合
@@ -2455,9 +2569,10 @@
                }
            }
            // 获取led线程
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getDevpPlcId());
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
            // led显示默认内容
            if (reset) {
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                }
@@ -2556,7 +2671,7 @@
                    }

                    // 处于充电库位组
                    if (steProtocol.getRow().intValue() == Utils.getRow(chargeLocNo)
                    if ( 0<steProtocol.getRow().intValue() && steProtocol.getRow().intValue()<=4
                            && steProtocol.getBay().intValue() == Utils.getBay(chargeLocNo)
                            && steProtocol.getLev().intValue() == Utils.getLev(chargeLocNo)) {
                        // 修改工作档状态 21.准备充电 => 24.小车到达
@@ -2583,10 +2698,26 @@
     */
    public synchronized void executeSteCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        if (null == wrkCharge) { return; }
        Integer steNo = wrkCharge.getSteNo();
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, 1);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (null == wrkCharge) {
            try{
                if (steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()){
                    SteCommand steCommand = new SteCommand();
                    steCommand.setSteNo(1); // 穿梭车编号
                    steCommand.setTaskNo(10060); // 工作号
                    steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                    if (!MessageQueue.offer(SlaveType.Ste, 1, new Task(2, steCommand))) {
                        News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                    }
                }
            }catch (Exception e){
                return;
            }
            return;
        }
        Integer steNo = wrkCharge.getSteNo();

        BasSte basSte = basSteService.selectById(steNo);
        if (Cools.isEmpty(steProtocol, basSte)) { return; }
        if (steProtocol.getMode() == 0
@@ -2600,10 +2731,35 @@
        if (!steProtocol.isEnable()) {
            return;
        }
        if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//充电标记
        if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())+40) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
            wrkCharge.setWrkSts(30L);
            wrkChargeMapper.updateById(wrkCharge);
            if (!wrkChargeService.updateById(wrkCharge)) {
                News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
            }else {
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                }
            }
            return;
        }else if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine()) && steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
            wrkCharge.setWrkSts(30L);
            if (!wrkChargeService.updateById(wrkCharge)) {
                News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
            }else {
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                }
            }
            return;
        }
        try {
@@ -2683,6 +2839,7 @@
                    }
                }
            } else if (wrkCharge.getWrkSts() == 26) {
                //26.等待充电 ===>
                // 穿梭车下发充电任务
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
@@ -2702,12 +2859,20 @@
                String chargeLine = SpringUtils.getBean(BasSteService.class).selectById(1).getChargeLine();
                if (idle2<(Float.parseFloat(chargeLine)+2)){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 666));//充电标记
                }else if (idle2 > 70f){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//充电标记
                }else if (idle2 >= 100f){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
                    // 29.开始充电 ===>> 30.完成充电
                    wrkCharge.setWrkSts(30L);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }else {
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                        steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                        if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                            News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                        }
                    }
                }
            }