#

luxiaotao1123

2022-10-11 efa33dcd491c9bbad681cd68300269566bf71897

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

@@ -8,6 +8,7 @@
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.BasCrnErrorMapper;
import com.zy.asrs.mapper.WrkChargeMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
@@ -15,6 +16,7 @@
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.core.CrnThread;
@@ -32,6 +34,7 @@
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.LedThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.core.thread.SteThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -41,10 +44,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -75,9 +75,19 @@
    @Autowired
    private BasErrLogService basErrLogService;
    @Autowired
    private BasSteErrLogService basSteErrLogService;
    @Autowired
    private BasCrnErrorMapper basCrnErrorMapper;
    @Autowired
    private BasSteService basSteService;
    @Autowired
    private WrkChargeService wrkChargeService;
    @Autowired
    private BasSteErrService basSteErrService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private WrkChargeMapper wrkChargeMapper;

    /**
     * 组托
@@ -111,11 +121,33 @@
                    }
                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
//                        log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            staProtocol.setWorkNo((short) 9995);
                            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) {
                                String errorMsg = "扫码失败，请重试";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                            }
                            continue;
                        }
                    } else {
                        staProtocol.setWorkNo((short) 9995);
                        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) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                        }
                        continue;
                    }

@@ -140,19 +172,39 @@
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                        Integer code = jsonObject.getInteger("code");
                        if (code.equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            // plc 处理
                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            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);
                        } else if (code == 500){
                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
                                if (!Cools.isEmpty(errorMsg)) {
                                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                                }
                            }
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        } else if (code == 700) {
                            staProtocol.setWorkNo((short) 9995);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
@@ -232,21 +284,21 @@
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()){

                    // 获取条码扫描仪信息
                    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;
                    }
//                    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;
//                    }

                    WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
                    WrkMast wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
                    if (wrkMast == null) {
                        // 无拣料数据
                        continue;
@@ -269,9 +321,9 @@

                    try {
                        // 保存工作明细档历史档
                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                            throw new CoolException("保存工作明细档历史档失败");
                        }
//                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
//                            throw new CoolException("保存工作明细档历史档失败");
//                        }
                        // 保存工作主档历史档
                        if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                            throw new CoolException("保存工作主档历史档失败");
@@ -289,6 +341,9 @@
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            throw new CoolException("更新工作档数据状态失败");
                        }
                        if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
//                            throw new CoolException("更新工作档数据状态失败");
                        }
                        // 修改库位状态 Q.拣料/盘点/并板再入库
                        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
@@ -429,6 +484,8 @@
                }
                // 库位移转
                this.locToLoc(crn, crnProtocol);
                // 演示任务
                this.steMoveDemo(crn, crnProtocol);
            }
        }
    }
@@ -479,15 +536,28 @@
                continue;
            }

            // 过滤
            if (null != wrkMastMapper.selectPakout(slave.getId(), null)) {
                log.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
                continue;
            }

            // 置顶任务
            wrkMast.setIoPri((double) 9999);
            wrkMastMapper.updateById(wrkMast);

            // 目标库位 ===>> 最外层库位
            if (locMastService.isOutMost(wrkMast.getLocNo())) {
                // 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
                Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                Integer steNo = this.hasCar(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
                        }
                    }
                    // 小车搬走
                    if (wrkMast.getWrkSts() == 3L) {
@@ -499,7 +569,7 @@
                    // 当前入库库位组没有小车 堆垛机则去站点取货入库
                    // case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
                    // case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
                    if (wrkMast.getWrkSts() == 2L || wrkMast.getWrkSts() == 6L) {
                    if ((wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) || wrkMast.getWrkSts() == 6L) {

                        // 已经存在吊车执行任务时，则过滤
                        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
@@ -543,7 +613,10 @@
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                        }
                    }
                    // 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入  ===>> 7.吊车入库中
                    if (wrkMast.getWrkSts() == 3L || wrkMast.getWrkSts() == 6L) {
@@ -590,8 +663,11 @@
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
                            // 让小车等待搬运待续
                            this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
                            // 没有其他任务
                            if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                // 让小车等待搬运待续
                                this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
                            }
                        }
                    }
                    // 堆垛机搬运小车
@@ -649,6 +725,16 @@
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

                // 过滤
                if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
                    log.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
                    continue;
                }

                // 置顶任务
                wrkMast.setIoPri((double) 9999);
                wrkMastMapper.updateById(wrkMast);

                // 最外层库位，直接堆垛机出库
                if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
@@ -760,8 +846,11 @@
                            // 寻找最近的小车
                            SteThread steThread = queryIdleCar(wrkMast);
                            if (steThread != null) {
                                // 让小车等待搬运待续
                                this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
                                // 没有其他任务
                                if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
                                    // 让小车等待搬运待续
                                    this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
                                }
                            }
                        }
                        // 堆垛机搬运小车
@@ -817,10 +906,16 @@
            return;
        }

        // 置顶任务
        wrkMast.setIoPri((double) 9999);
        wrkMastMapper.updateById(wrkMast);

        // 源库位 ===>> 最外层库位
        if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
            // 目标库位 ===>> 最外层库位
            if (locMastService.isOutMost(wrkMast.getLocNo())) {
                // todo:luxiaotao 判断目标库位是否存在小车，如果存在，则搬走小车

                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
@@ -851,6 +946,11 @@
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                        // 标记移库当前流程
                        wrkMast.setMk("I");
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                    }
                    // 堆垛机将货放至小车上 6.小车待入  ===>> 7.吊车入库中
@@ -913,6 +1013,7 @@
            }

        } else {

            // 当前组库位是否有穿梭车
            Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
            // 有小车
@@ -981,9 +1082,13 @@
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                            wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
//                            wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
                        }
                    } else {

                        // 把货搬到临时存放货位 todo:luxiaotao


                        // 小车行走到堆垛机待搬移点
                        if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
@@ -1055,6 +1160,22 @@
    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCar(String locNo) {
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
                return steProtocol.getSteNo().intValue();
            }
        }
        return null;
    }

    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCarOfIdle(String locNo) {
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
@@ -1121,6 +1242,39 @@
        }
    }

    public void letCarBeWaiting(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }

        if (!basSteService.updatePakMk(steNo, "Y")) {
            log.error("修改穿梭车作业状态 失败！！，穿梭车={}", steNo);
            return;
        }

        // 命令下发区 --------------------------------------------------------------------------
        SteCommand steCommand = new SteCommand();
        steCommand.setSteNo(steNo); // 穿梭车编号
        steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
        steCommand.setTaskMode(SteTaskModeType.findOriginByLoc(steProtocol.getRow())); // 任务模式:  去近点 等待堆垛机叉取

        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
        steCommand.setBay(steProtocol.getBay());
        steCommand.setLev(steProtocol.getLev());

        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
        } else {
            // 修改工作档状态 绑定穿梭车
            wrkCharge.setSteNo(steNo);
            wrkCharge.setModiTime(new Date());
            if (!wrkChargeService.updateById(wrkCharge)) {
                log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkCharge.getWrkNo());
            }
        }
    }

    /**
     * 让小车从 远点 ====>> 移动到近点
     *  等待堆垛机搬运
@@ -1150,6 +1304,40 @@
                wrkMast.setModiTime(new Date());
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkMast.getWrkNo());
                }
            }
        }
    }

    /**
     * 让小车从 远点 ====>> 移动到近点
     *  等待堆垛机搬运
     */
    public void letCarBeReady(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
            steCommand.setSteNo(steNo); // 穿梭车编号
            steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
            steCommand.setTaskMode(SteTaskModeType.findOriginByLoc(steProtocol)); // 任务模式:  去近点 等待堆垛机叉取

            steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
            steCommand.setBay(steProtocol.getBay());
            steCommand.setLev(steProtocol.getLev());

            if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
            } else {
                // 修改工作档状态 绑定穿梭车
                wrkCharge.setSteNo(steNo);
                wrkCharge.setModiTime(new Date());
                if (!wrkChargeService.updateById(wrkCharge)) {
                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkCharge.getWrkNo());
                }
            }
        }
@@ -1256,8 +1444,8 @@
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(steProtocol.getRow());     // 源库位排
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                crnCommand.setDestinationPosX(Utils.getGroupRow(idleLocNo).shortValue());     // 目标库位排
@@ -1298,9 +1486,47 @@
                // 获取入库待确认工作档
                WrkMast wrkMast = wrkMastMapper.selectCrnWaiting(crnProtocol.getTaskNo().intValue());
                if (wrkMast == null) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    continue;

                    // 充电任务
                    WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
                    if (wrkCharge == null) {
                        log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    } else {
                        // 小车搬至指定库位完成
                        if (wrkCharge.getWrkSts() == 23) {
                            // 23.吊车搬运 ===>> 24.小车到达
                            wrkCharge.setWrkSts(24L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 34) {
                            // 34.吊车搬运 ===>> 35.小车就绪
                            wrkCharge.setWrkSts(35L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改充电任务状态 34.吊车搬运 ===>> 35.小车就绪 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        }
                    }

                }
                if (wrkMast == null) { continue; }
                if (wrkMast.getIoType() != 11) {
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
@@ -1463,6 +1689,37 @@
                        } else {
                            log.error("修改工作档状态 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    } else if (wrkMast.getWrkSts() == 4) {
                        // 4.迁入小车 ==> 6.小车待入
                        wrkMast.setWrkSts(6L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
                            if (!steThread.confirmPos()) {
                                log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                            }
                            // 穿梭车去待机位
                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(9999); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
//                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
//                        steCommand.setBay(steProtocol.getBay());
//                        steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            log.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 入库 ===>> 迁出小车 完成
                    } else if (wrkMast.getWrkSts() == 7){
                        // 判断是否需要小车入库
                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
@@ -1547,7 +1804,7 @@
    /**
     * 执行对工作档的完成操作
     */
    public void carGenerateStore() {
    public synchronized void carGenerateStore() {
        Date now = new Date();
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取穿梭车信息
@@ -1560,8 +1817,49 @@
                } else {
                    // 查询是否有待入库的任务
                    WrkMast wrkMast = wrkMastMapper.selectCarWaiting(steProtocol.getTaskNo().intValue());
                    if (wrkMast == null) { continue; }
                    if (wrkMast == null) {
                        // 充电任务
                        WrkCharge wrkCharge = wrkChargeService.selectById(steProtocol.getTaskNo());
                        if (wrkCharge == null) {
                            continue;
                        } else {
                            if (wrkCharge.getWrkSts() == 21) {
                                // 21.准备充电 ===>> 22.小车待搬
                                wrkCharge.setWrkSts(22L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 25) {
                                // 25.小车去充电 ===>> 26.等待充电
                                wrkCharge.setWrkSts(26L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }  else if (wrkCharge.getWrkSts() == 32) {
                                // 32.小车走行 ===>> 33.小车待搬
                                wrkCharge.setWrkSts(33L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 36) {
                                // 36.小车走行 ===>> 37.演示完成
                                wrkCharge.setWrkSts(37L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
                        }
                    }

                    if (wrkMast == null) { continue; }
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 2:
                            // 修改工作档状态 2.设备上走 => 3.小车待搬
@@ -1630,10 +1928,21 @@
    }

    /**
     * 异常信息记录
     */
    public void recErr() {
        try {
            this.recCrnErr();
            this.recSteErr();
        } catch (Exception e) {
            log.error("recErr fail", e);
        }
    }

    /**
     * 堆垛机异常信息记录
     */
    @Async
    public void recCrnErr(){
    private void recCrnErr(){
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -1642,109 +1951,219 @@
            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);
                            }
            // 有任务
            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;
                        }
                    } 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());
                            }
                        BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                        String errName = crnError==null? "未知异常":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 {
                    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);
                            }
                    // 异常修复
                    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 {
                        // 异常修复
                        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());
                            }
                    }
                }
            // 无任务
            } 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? "未知异常":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());
                        }
                    }
                }
            }
        }
    }

    /**
     * 穿梭车异常信息记录
     */
    private void recSteErr(){
        Date now = new Date();
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) {
                continue;
            }
            // 有任务
            if (steProtocol.getTaskNo() != 0) {
                BasSteErrLog latest = basSteErrLogService.findLatestByTaskNo(ste.getId(), steProtocol.getTaskNo().intValue());
                // 有异常
                if (latest == null) {
                    if (steProtocol.getAlarm() != null && steProtocol.isAlarm()) {
                        WrkMast wrkMast = wrkMastMapper.selectById(steProtocol.getTaskNo());
                        if (wrkMast == null) {
                            continue;
                        }
                        BasSteErr steErr = basSteErrService.selectById(steProtocol.getAlarm());
                        String errName = steErr==null? "未知异常":steErr.getErrName();
                        BasSteErrLog basSteErrLog = new BasSteErrLog(
                                null,    // 编号
                                wrkMast.getWrkNo(),    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                wrkMast.getWrkSts(),    // 工作状态
                                wrkMast.getIoType(),    // 入出库类型
                                ste.getId(),    // 堆垛机
                                null,    // plc
                                wrkMast.getLocNo(),    // 目标库位
                                wrkMast.getStaNo(),    // 目标站
                                wrkMast.getSourceStaNo(),    // 源站
                                wrkMast.getSourceLocNo(),    // 源库位
                                wrkMast.getBarcode(),    // 条码
                                (int) steProtocol.getAlarm(),    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "任务中异常"    // 备注
                        );
                        if (!basSteErrLogService.insert(basSteErrLog)) {
                            log.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
                        }
                    }
                } else {
                    // 异常修复
                    if (steProtocol.getAlarm() == null || !steProtocol.isAlarm()) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basSteErrLogService.updateById(latest)) {
                            log.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
                        }
                    }
                }
                // 无任务
            } else {
                BasSteErrLog latest = basSteErrLogService.findLatest(ste.getId());
                // 有异常
                if (steProtocol.getAlarm() != null && steProtocol.isAlarm()) {
                    // 记录新异常
                    if (latest == null || (latest.getErrCode() != steProtocol.getAlarm().intValue())) {
                        BasSteErr steErr = basSteErrService.selectById(steProtocol.getAlarm());
                        String errName = steErr==null? "未知异常":steErr.getErrName();
                        BasSteErrLog basSteErrLog = new BasSteErrLog(
                                null,    // 编号
                                null,    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                null,    // 工作状态
                                null,    // 入出库类型
                                ste.getId(),    // 堆垛机
                                null,    // plc
                                null,    // 目标库位
                                null,    // 目标站
                                null,    // 源站
                                null,    // 源库位
                                null,    // 条码
                                (int)steProtocol.getAlarm(),    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "无任务异常"    // 备注
                        );
                        if (!basSteErrLogService.insert(basSteErrLog)) {
                            log.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
                        }
                    }
                    // 无异常
                } else {
                    // 异常修复
                    if (latest != null && latest.getStatus() == 1) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basSteErrLogService.updateById(latest)) {
                            log.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
                        }
                    }
                }
            }
        }
    }

@@ -1768,14 +2187,36 @@
                    staProtocol = staProtocol.clone();
                }
                // 站点条件判断
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 ||  (staProtocol.getWorkNo() >= 9990 && staProtocol.getWorkNo() <= 9999) || staProtocol.getWorkNo() == 9997) && staProtocol.isPakMk()) {
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk()
                        && (staProtocol.getWorkNo() == 0 || (staProtocol.getWorkNo() >= 9990 || staProtocol.getWorkNo() <= 9999))
                        && staProtocol.isPakMk()) {

                    // 获取条码扫描仪信息
                    String barcode = null;
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, emptyInSta.getBarcode());
                    if (barcodeThread != null) {
                        String barcode0 = barcodeThread.getBarcode();
                        if(!Cools.isEmpty(barcode0)) {
//                            log.info("{}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode0);
                            if(!"NG".endsWith(barcode0) && !"NoRead".equals(barcode0) && !"empty".equals(barcode0)) {
                                barcode = barcode0;
                            }
                        }
                    }

                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());

                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

                        SearchLocParam param = new SearchLocParam();
                        param.setIoType(10);
                        if (!Cools.isEmpty(barcode)) {
                            param.setBarcode(barcode);
                        }
                        param.setSourceStaNo(emptyInSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
@@ -1785,7 +2226,8 @@
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                        Integer code = jsonObject.getInteger("code");
                        if (code.equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            // 更新站点信息 且 下发plc命令
@@ -1797,7 +2239,13 @@
                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
                                if (!Cools.isEmpty(errorMsg)) {
                                    MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(3, errorMsg));
                                }
                            }
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
@@ -1942,4 +2390,344 @@
        }
    }

    /**
     * 小车电量检测 ===>> 发起充电
     */
    public synchronized void loopSteCharge() {
        for (SteSlave ste : slaveProperties.getSte()) {
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            BasSte basSte = basSteService.selectById(ste.getId());
            if (Cools.isEmpty(steProtocol, basSte)) { continue; }
            try {
                // 在线 空闲   无作业标记   不在充电
                if (steProtocol.getMode() == 0
                        || !steProtocol.statusType.equals(SteStatusType.IDLE)
                        || basSte.getPakMk().equals("Y")
//                        || steProtocol.getChargeStatus() == 1
                ) {
                    continue;
                }
                if (!steProtocol.isEnable()) {
                    continue;
                }
                if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                WrkCharge wrkCharge = wrkChargeService.selectWorking(steProtocol.getSteNo().intValue());

                if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
                    String idleLoc = basSte.getIdleLoc();
                    wrkCharge = new WrkCharge();
                    wrkCharge.setSteNo(ste.getId());
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
                    wrkCharge.setWrkSts(21L);   // 21.准备充电
                    wrkCharge.setCrnNo(basSte.getCrnNo());
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setLocNo(idleLoc);
                    if (!wrkChargeService.insert(wrkCharge)) {
                        log.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
                        continue;
                    }

                    // 处于充电库位组
                    if (Utils.getGroupRow(idleLoc).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(idleLoc) && steProtocol.getLev() == Utils.getLev(idleLoc)) {
                        // 修改工作档状态 21.准备充电 => 24.小车到达
                        wrkCharge.setWrkSts(24L);
                        wrkCharge.setModiTime(new Date());
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            log.error("修改充电任务状态 21.准备充电 => 24.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    } else {
                        this.letCarBeWaiting(wrkCharge, ste.getId());
                    }

                } else {
                    // filter
                    if (wrkCharge == null || (wrkCharge.getWrkSts() < 26 && steProtocol.getChargeStatus() == 1)) {
                        continue;
                    }

                    // 22.小车待搬
                    if (wrkCharge.getWrkSts() == 22) {
                        // 搬小车至充电库位
                        LocMast locMast = locMastService.selectById(basSte.getIdleLoc());

                        // 堆垛机命令下发区 --------------------------------------------------------------------------
                        CrnCommand crnCommand = new CrnCommand();
                        crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                        crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                        crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                        crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue());     // 目标库位排
                        crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                        crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                        if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 修改穿梭车运行中排列层
                            steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
                            // 修改工作档状态 22.小车待搬 => 23.吊车搬运
                            Date now = new Date();
                            wrkCharge.setWrkSts(23L);
                            wrkCharge.setCrnStrTime(now);
                            wrkCharge.setModiTime(now);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                            }
                        }

                    } else if (wrkCharge.getWrkSts() == 24L) {
                        // 小车行驶至充电位
                        if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
                            if (steProtocol.getChargeStatus() == 1) { continue; }
                            // 命令下发区 --------------------------------------------------------------------------
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findChargeByLoc(steProtocol.getRow().intValue()));
                            if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                            } else {
                                // 修改工作档状态 24.小车到达 ===> 25.小车去充电
                                wrkCharge.setWrkSts(25L);
                                Date now = new Date();
                                wrkCharge.setCrnEndTime(now);
                                wrkCharge.setModiTime(now);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 24.小车到达 ===> 25.小车去充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                        }
                    } else if (wrkCharge.getWrkSts() == 26) {
                        if (steProtocol.getChargeStatus() == 0) { continue; }
                        // 给输送线下发充电任务
                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                        SteChargeType steChargeType = SteChargeType.get(wrkCharge.getLocNo());
                        if (null != steChargeType) {
                            if (devpThread.charge(steChargeType.ssbm - 1, true)) {
                                // 修改工作档状态 26.等待充电 ===> 28.完成充电
                                wrkCharge.setWrkSts(28L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 26.等待充电 ===> 28.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
                        } else {
                            log.error("获取充电桩号失败，解析库位：{}", wrkCharge.getLocNo());
                        }
                    }
                }
            } catch (Exception e) {
                log.error("fail", e);
            }
        }
    }


    public List<String> crn1DemoLocs = new ArrayList<String>(); public String crn1LastLoc = "";
    public List<String> crn2DemoLocs = new ArrayList<String>(); public String crn2LastLoc = "";
    public List<String> crn3DemoLocs = new ArrayList<String>(); public String crn3LastLoc = "";
    public synchronized void demo() {
        if (Cools.isEmpty(crn1DemoLocs)) {
            crn1DemoLocs = locMastService.getDemoNextLoc(1);
        }
        if (Cools.isEmpty(crn2DemoLocs)) {
            crn2DemoLocs = locMastService.getDemoNextLoc(2);
        }
        if (Cools.isEmpty(crn3DemoLocs)) {
            crn3DemoLocs = locMastService.getDemoNextLoc(3);
        }
        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) {

                // filter
                if (wrkChargeService.selectCount(new EntityWrapper<WrkCharge>()
                        .eq("crn_no", crn.getId()).between("wrk_sts", 31, 36)) > 0) {
                    continue;
                }

                int steNo = crn.getId();
                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                SteProtocol steProtocol = steThread.getSteProtocol();
                BasSte basSte = basSteService.selectById(steNo);
                if (Cools.isEmpty(steProtocol, basSte)) { continue; }

                // 只有当穿梭车空闲 并且 无任务时才继续执行
                if (steProtocol.isIdle()) {

                    String locNo = null;
                    Iterator<String> iterator = crn1DemoLocs.iterator();
                    if (crn.getId() == 1) {
                        iterator = crn1DemoLocs.iterator();
                    } else if (crn.getId() == 2) {
                        iterator = crn2DemoLocs.iterator();
                    } else if (crn.getId() == 3) {
                        iterator = crn3DemoLocs.iterator();
                    }
                    while (iterator.hasNext()) {
                        String next = iterator.next();
                        String lastLoc = "";
                        if (crn.getId() == 1) {
                            lastLoc = crn1LastLoc;
                        } else if (crn.getId() == 2) {
                            lastLoc = crn2LastLoc;
                        } else if (crn.getId() == 3) {
                            lastLoc = crn3LastLoc;
                        }
                        if (!Cools.isEmpty(lastLoc)) {
                            if (!lastLoc.substring(2, 7).equals(next.substring(2, 7)) || !Utils.getGroupRow(lastLoc).equals(Utils.getGroupRow(next))) {
                                locNo = next;
                                iterator.remove();
                                break;
                            } else {
                                iterator.remove();
                            }
                        } else {
                            locNo = next;
                            iterator.remove();
                            break;
                        }

                    }
                    if (!Cools.isEmpty(locNo)) {
                        if (crn.getId() == 1) {
                            crn1LastLoc = locNo;
                        } else if (crn.getId() == 2) {
                            crn2LastLoc = locNo;
                        } else if (crn.getId() == 3) {
                            crn3LastLoc = locNo;
                        }
                    }

                    log.info("{}号堆垛机对{}库位进行演示", crn.getId(), locNo);

                    String sourceLocNo = Utils.getLocNo(steProtocol.getRow(), steProtocol.getBay(), steProtocol.getLev());

                    WrkCharge wrkCharge = new WrkCharge();
                    wrkCharge.setCrnNo(crn.getId());
                    wrkCharge.setSteNo(steNo);
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(5));
                    wrkCharge.setWrkSts(31L);   // 31.生成演示ID
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setSourceLocNo(sourceLocNo);
                    wrkCharge.setLocNo(locNo);
                    if (!wrkChargeService.insert(wrkCharge)) {
                        log.error("生成演示任务失败，堆垛机号：{}，小车：{}，源库位：{}，目标库位：{}", crn.getId(), steNo, sourceLocNo, locNo);
                        continue;
                    }
                }
            }
        }
    }

    /**
     * 演示取货
     */
    private void steMoveDemo(CrnSlave slave, CrnProtocol crnProtocol) {
        // 获取工作档信息
        WrkCharge wrkCharge = wrkChargeService.selectOne(new EntityWrapper<WrkCharge>().eq("crn_no", slave.getId())
                .in("wrk_sts", 31, 33, 35));
        if (null == wrkCharge) {
            return;
        }
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (null == steProtocol) { return; }
        if (steProtocol.isIdle()) {
            // 31.生成演示ID
            if (wrkCharge.getWrkSts() == 31L) {
                this.letCarBeReady(wrkCharge, steProtocol.getSteNo().intValue());
                wrkCharge.setWrkSts(32L);
                wrkCharge.setModiTime(new Date());
                if (!wrkChargeService.updateById(wrkCharge)) {
                    log.error("修改演示任务{}工作档 31.生成演示ID ==>> 32.小车走行 失败!", wrkCharge.getWrkNo());
                }
            // 33.小车待搬
            } else if (wrkCharge.getWrkSts() == 33L) {
                LocMast locMast = locMastService.selectById(wrkCharge.getLocNo());
                // 堆垛机命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue());     // 目标库位排
                crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改穿梭车运行中排列层
                    steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
                    // 修改工作档状态 33.小车待搬 => 34.吊车搬运
                    Date now = new Date();
                    wrkCharge.setWrkSts(34L);
                    wrkCharge.setCrnStrTime(now);
                    wrkCharge.setModiTime(now);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        log.error("修改演示任务{}工作档 33.小车待搬 => 34.吊车搬运 失败!", wrkCharge.getWrkNo());
                    }
                }
            // 35.小车就绪
            } else if (wrkCharge.getWrkSts() == 35L) {

                int steNo = steProtocol.getSteNo().intValue();
                if (!basSteService.updatePakMk(steNo, "Y")) {
                    log.error("修改穿梭车作业状态 失败！！，穿梭车={}", steNo);
                    return;
                }

                // 命令下发区 --------------------------------------------------------------------------
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(steNo); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                SteTaskModeType originByLoc = SteTaskModeType.findOriginByLoc(steProtocol.getRow());
                if (originByLoc.equals(SteTaskModeType.GO_ORIGIN)) {
                    originByLoc = SteTaskModeType.BACK_ORIGIN;
                } else if (originByLoc.equals(SteTaskModeType.BACK_ORIGIN)) {
                    originByLoc = SteTaskModeType.GO_ORIGIN;
                } else {
                    return;
                }
                steCommand.setTaskMode(originByLoc);

                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
                steCommand.setBay(steProtocol.getBay());
                steCommand.setLev(steProtocol.getLev());

                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                } else {
                    // 修改工作档状态 35.小车就绪 => 36.小车走行
                    wrkCharge.setWrkSts(36L);
                    wrkCharge.setModiTime(new Date());
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        log.error("修改演示任务{}工作档 35.小车就绪 => 36.小车走行 失败!", wrkCharge.getWrkNo());
                    }
                }
            }
        }

    }


}