#

zjj

3 天以前 c904f735e0b8a488ef56744c08f8e10258639bce

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

@@ -3,48 +3,48 @@
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.R;
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.WMSAndAGVInterfaceParam;
import com.zy.asrs.entity.param.taskCreateParam;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.PostMesDataUtils;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
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.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.RgvThread;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.CommandPackage;
import com.zy.core.model.*;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.command.LedCommand;
import com.zy.core.model.command.RgvCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.ExtProtocol;
import com.zy.core.model.protocol.RgvProtocol;
import com.zy.core.model.protocol.StaProtocol;
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.system.entity.Config;
import com.zy.system.service.ConfigService;
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.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 立体仓库WCS系统主流程业务
@@ -58,230 +58,68 @@
    public static final long COMMAND_TIMEOUT = 5 * 1000;

    @Autowired
    private CommonService commonService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private WrkMastMapper wrkMastMapper;
    private WrkMastStaMapper wrkMastStaMapper;
    @Autowired
    private LocMastService locMastService;
    private FillingMastService fillingMastService;
    @Autowired
    private BasCrnpService basCrnpService;
    @Autowired
    private BasDevpService basDevpService;
    private VacuumMastService vacuumMastService;
    @Autowired
    private BasErrLogService basErrLogService;
    @Autowired
    private BasCrnErrorMapper basCrnErrorMapper;
    private WrkMastStaService wrkMastStaService;
    @Autowired
    private TaskWrkMapper taskWrkMapper;
    @Autowired
    private TaskWrkService taskWrkService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private StaDescMapper staDescMapper;
    @Autowired
    private CommandInfoService commandInfoService;

    @Autowired
    private OpenServiceImpl openServiceImpl;
    private BasRgvErrService basRgvErrService;

    @Value("${wms.url}")
    private String wmsUrl;
    @Value("${wms.movePath}")
    private String movePath;

    public Integer wrkNo1 = 10000;

    public void generateStoreWrkFile() throws IOException {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                // 获取入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();
                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (workNo >= 0)
                        && staProtocol.isPakMk()) {
    public Integer wrkNo2 = 20000;

                    // 尺寸检测异常
                    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(workNo);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
                        if (taskWrk != null) {
                            taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
                            taskWrkMapper.updateById(taskWrk);
                        }
                        continue;
                    }
                    // 获取条码扫描仪信息
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                    if (barcodeThread == null) {
                        continue;
                    }
                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        ToWmsDTO toWmsDTO = new ToWmsDTO();
                        Map<String, Object> map = new HashMap<>();
                        map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
                        List<Integer> list = openServiceImpl.getInEnableRoadway();
                        TaskWrk taskWrk = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode).eq("crn_no",inSta.getBarcode()));
                        if (Cools.isEmpty(taskWrk)){
                            continue;
                        }
                        if (taskWrk.getTargetPoint() != null && taskWrk.getStartPoint() != null && taskWrk.getWrkNo() != null){
                            staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                            staProtocol.setStaNo(inSta.getStaNo().shortValue());
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        }else {
                            //TaskWrk taskWrk = taskWrkService.selectByTaskNo(param.getTaskNo());
                            toWmsDTO.setWarehouseId("1688469798893297665");
                            toWmsDTO.setContainerCode(barcode);
                            toWmsDTO.setApplyType("TUNNEL_LOCATION");
                            toWmsDTO.setTaskTunnel(taskWrk.getCrnNo());
                            toWmsDTO.setCanInboundTunnels(list);
                            String response = null;
                            try {
                                response = new HttpHandler.Builder()
                                        .setHeaders(map)
                                        .setUri(wmsUrl)
                                        .setPath("wcsManager/wcsInterface/inboundTaskApply")
                                        .setJson(JSON.toJSONString(toWmsDTO))
                                        .build()
                                        .doPost();
                            }catch (Exception e){
                                log.error("wms通讯失败,"+e.getMessage());
                                continue;
                            }
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {
                                GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);

                                taskWrk.setTargetPoint(Utils.getWcsLocNo(getWmsDto.getTargetLocationCode()));
                                taskWrk.setStartPoint(String.valueOf(inSta.getBackSta()));
                                if (!taskWrkService.updateById(taskWrk)){
                                    log.error("保存wms库位号失败");
                                }

                            }else {
                                log.error("wms通讯失败,"+jsonObject.get("msg"));

                            }
                        }

                    }
                }


            }
        }
    }


    /**
     * 堆垛机站出库到出库站
     * 堆垛机演示  ===>> 库位移转
     */
    @Async
    public void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));
                for (StaDesc staDesc : staDescs){
                    // 获取堆垛机出库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
    public void getRgvTask() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                for (RgvSlave rgv : slaveProperties.getRgv()) {
                    if (!rgv.getDemo()){
                        continue;
                    }
                    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 (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                        // 查询工作档
                        TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
                        if (taskWrk == null) {
                            continue;
                        }
                        // 判断工作档条件
                        if (taskWrk.getWrkSts() == 12 && taskWrk.getIoType() == 2) {
                            // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, taskWrk.getCrnNo());
                            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                            if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                                // 移动中
                                continue;
                            }
                            //  判断堆垛机状态等待确认
                            if (crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(taskWrk.getWrkNo().shortValue())
                                    && crnProtocol.getTaskFinish() == 0
                                    && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                                // 命令下发区 --------------------------------------------------------------------------

                                //取出输送线命令
                                List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
                                if (commandInfos.isEmpty()) {
                                    continue;//命令空
                                }

//                                CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
//                                CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
                                Integer commandStep = taskWrk.getCommandStep();
                                CommandInfo commandInfo = commandInfos.get(commandStep);
                                CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
                                //StaProtocol staProtocol1 = JSON.parseObject(commandInfo.getCommand(), StaProtocol.class);
                                StaProtocol staProtocol1 = JSON.parseObject(commandPackage.getCommand().toString(), StaProtocol.class);
                                if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol1))) {
                                    log.error("输送线命令下方失败！！！ [工作号:{}]", taskWrk.getWrkNo());
                                    continue;//命令下发失败
                                }

                                // 复位堆垛机
                                crnThread.setResetFlag(true);

                            }
                    if (staProtocol.isPakMk()){
                        VacuumMast vacuumMast = vacuumMastService.selectByStatusIsN();
                        FillingMast fillingMast = fillingMastService.selectByStatusIsn();
                        Date now = new Date();
                        WrkMastSta wrkMastSta = new WrkMastSta();
                        int workNo = commonService.getWorkNo(0);
                        wrkMastSta.setWrkNo((long)workNo);
                        wrkMastSta.setWrkStart(2);
                        wrkMastSta.setWrkEnd(vacuumMast.getStaNo());
//                    wrkMastSta.setStaStart();
                        wrkMastSta.setStaEnd(fillingMast.getStaNo());
                        wrkMastSta.setCreateTime(now);
                        wrkMastSta.setUpdateTime(now);
                        wrkMastSta.setBignTime(now);
                        wrkMastSta.setType(0);      //类型 0:非空  1:空板
                        wrkMastSta.setWrkType(3);                      //工作类型  1:取（叠盘）  2：放 3：取放 4：拆盘
                        Integer insert = wrkMastStaMapper.insert(wrkMastSta);
                        if (insert>0){
                            devpThread.setPakMk(devp.getId(),false);
                        }
                    }
                }
@@ -289,443 +127,477 @@
            }
        }
    }
    public synchronized void RGVDemoShow0() {
        try {
            for (DevpSlave devp : slaveProperties.getDevp()) {
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    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 (){ //输送线状态
//
//                    }

    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecute() throws IOException {
        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());
                    for (RgvSlave rgv : slaveProperties.getRgv()) {

                        SiemensRgvThread rgvThread = (SiemensRgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
                        RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                        if (rgvProtocol == null) {
                            continue;
                        }else {
                            rgvProtocol = rgvProtocol.clone();
                        }
                        if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                                && rgvProtocol.getModeType() == RgvModeType.AUTO
                                && rgvProtocol.getLoaded1()==0
                                && rgvProtocol.getTaskNo1() == 0
                                && rgvThread.isPakMk()
                        ){
                            WrkMastSta wrkMastSta = wrkMastStaMapper.selectWrkSts0();
                            if (!Cools.isEmpty(wrkMastSta)){
                                //  命令下发区 --------------------------------------------------------------------------
                                RgvCommand rgvCommand = new RgvCommand();
                                rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                                rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                                rgvCommand.setTaskNo1(wrkNo1); // 工位1工作号
                                rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
                                rgvCommand.setSourceStaNo1(wrkMastSta.getWrkStart().shortValue());   //工位1起点
                                rgvCommand.setDestinationStaNo1(wrkMastSta.getWrkEnd().shortValue());   //工位1目标站点
                                rgvCommand.setCommand((short) 1);   //工位1任务确认
                                if (!MessageQueue.offer(SlaveType.Rgv, rgv.getId(), new Task(4, rgvCommand))) {
                                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));

                                } else {
                                    vacuumMastStatusSetY(wrkMastSta.getWrkEnd());
                                    rgvThread.setPakMk(false);

                                    wrkMastSta.setWrkSts(1);
                                    Integer update = wrkMastStaMapper.updateById(wrkMastSta);
                                    if (update>0){

                                    }else {
                                        log.error("RGV命令下发后，更新工作任务状态失败");
                                    }

                                }

                            }


                        }

                    }
                }

            }

        } catch (Exception e) {
            log.error("Rgv演示  ===>> 失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    public synchronized void RGVDemoShow1() {
        try {
            for (DevpSlave devp : slaveProperties.getDevp()) {
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    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 (){ //输送线状态
//
//                    }

                    for (RgvSlave rgv : slaveProperties.getRgv()) {
                        if (!rgv.getDemo()) {
                            continue;
                        }
                        SiemensRgvThread rgvThread = (SiemensRgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
                        RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                        if (rgvProtocol == null) {
                            continue;
                        }else {
                            rgvProtocol = rgvProtocol.clone();
                        }
                        if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                                && rgvProtocol.getModeType() == RgvModeType.AUTO
                                && rgvProtocol.getLoaded1()==0
                                && rgvProtocol.getTaskNo1() == 0
                                && rgvThread.isPakMk()
                        ){
                            WrkMastSta wrkMastSta = wrkMastStaMapper.selectWrkSts1();
                            if (!Cools.isEmpty(wrkMastSta)){
                                //  命令下发区 --------------------------------------------------------------------------
                                RgvCommand rgvCommand = new RgvCommand();
                                rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                                rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                                rgvCommand.setTaskNo1(wrkNo1); // 工位1工作号
                                rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
                                rgvCommand.setSourceStaNo1(wrkMastSta.getWrkEnd().shortValue());   //工位1起点
                                rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
                                rgvCommand.setCommand((short) 1);   //工位1任务确认
                                if (!MessageQueue.offer(SlaveType.Rgv, rgv.getId(), new Task(4, rgvCommand))) {
                                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));

                                } else {
                                    rgvThread.setPakMk(false);
                                    vacuumMastStatusSetN(wrkMastSta.getWrkEnd());
                                    fillingMastStatusSetY(wrkMastSta.getStaEnd());

                                    wrkMastSta.setWrkSts(2);
                                    Integer update = wrkMastStaMapper.updateById(wrkMastSta);
                                    if (update>0){

                                    }else {
                                        log.error("RGV命令下发后，更新工作任务状态失败");
                                    }

                                }

                            }


                        }

                    }
                }

            }

        } catch (Exception e) {
            log.error("Rgv演示  ===>> 失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    public synchronized void RGVDemoShow2() throws InterruptedException {
        for (RgvSlave rgv : slaveProperties.getRgv()) {
//            if (!rgv.getDemo()) {
//                continue;
//            }
            SiemensRgvThread rgvThread = (SiemensRgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                continue;
            }else {
                rgvProtocol = rgvProtocol.clone();
            }
            if ((rgvProtocol.getStatusType1() == RgvStatusType.WAITING || rgvProtocol.getStatusType1()==RgvStatusType.FETCHWAITING)
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1() >0
//                    && (rgvProtocol.getStatusType() == RgvStatusType.WORKING1)
            ){
                boolean rgvComplete = rgvComplete(rgv.getId());
                if (rgvComplete){
                    rgvThread.setPakMk(true);
                }
                List<WrkMastSta> wrkMastStas = wrkMastStaMapper.selectList(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", rgvProtocol.getTaskNo1()));
                if (!Cools.isEmpty(wrkMastStas) || wrkMastStas.size()<=0){
                    WrkMastSta wrkMastSta = wrkMastStas.get(0);
                    wrkMastSta.setWrkSts(3);
                    wrkMastSta.setBignTime(new Date());
                    wrkMastStaMapper.updateById(wrkMastSta);
                }
            }

        }
    }

    public boolean vacuumMastStatusSetN(Integer staNo){
        EntityWrapper<VacuumMast> vacuumMastEntityWrapper = new EntityWrapper<>();
        vacuumMastEntityWrapper.eq("sta_no",staNo);
        VacuumMast vacuumMast = vacuumMastService.selectOne(vacuumMastEntityWrapper);
        vacuumMast.setStatus("N");
        boolean update = vacuumMastService.update(vacuumMast, vacuumMastEntityWrapper);
        return update;
    }
    public boolean vacuumMastStatusSetY(Integer staNo){
        EntityWrapper<VacuumMast> vacuumMastEntityWrapper = new EntityWrapper<>();
        vacuumMastEntityWrapper.eq("sta_no",staNo);
        VacuumMast vacuumMast = vacuumMastService.selectOne(vacuumMastEntityWrapper);
        vacuumMast.setStatus("Y");
        boolean update = vacuumMastService.update(vacuumMast, vacuumMastEntityWrapper);
        return update;
    }
    public boolean fillingMastStatusSetN(Integer staNo){
        EntityWrapper<FillingMast> fillingMastEntityWrapper = new EntityWrapper<>();
        fillingMastEntityWrapper.eq("sta_no",staNo);
        FillingMast fillingMast = fillingMastService.selectOne(fillingMastEntityWrapper);
        fillingMast.setStatus("N");
        boolean update = fillingMastService.update(fillingMast, fillingMastEntityWrapper);
        return update;
    }

    public boolean fillingMastStatusSetY(Integer staNo){
        EntityWrapper<FillingMast> fillingMastEntityWrapper = new EntityWrapper<>();
        fillingMastEntityWrapper.eq("sta_no",staNo);
        FillingMast fillingMast = fillingMastService.selectOne(fillingMastEntityWrapper);
        fillingMast.setStatus("Y");
        boolean update = fillingMastService.update(fillingMast, fillingMastEntityWrapper);
        return update;
    }



    /*
     * 小车复位
     * */
    public synchronized boolean rgvComplete(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(3, new RgvCommand()))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}",rgvId);
                return false;
            } else {
                log.info("RGV命令下发成功，RGV号={}",rgvId);
                return true;
            }
        }catch (Exception e){
            log.error("RGV命令下发失败，RGV号={}。异常："+e,rgvId);
            return false;
        }
    }

    public synchronized void ExtTaskAndPut() throws InterruptedException {
        for (ExtSlave extSlave : slaveProperties.getExt()) {
//            if (!rgv.getDemo()) {
//                continue;
//            }
            MelsecExtThread extThread = (MelsecExtThread) SlaveConnection.get(SlaveType.Ext, extSlave.getId());
            ExtProtocol extProtocol = extThread.getExtProtocol();
            if (extProtocol == null) {
                continue;
            }
//            else {
//                extProtocol = extProtocol.clone();
//            }
            if (extProtocol.isTake()){//允许取

            // 只有当堆垛机空闲 并且 无任务时才继续执行
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
                    && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {
                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
                        this.crnStnToLoc(crn, crnProtocol); //  入库
                        crnProtocol.setLastIo("O");
                    } else if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrnStn(crn, crnProtocol); //  出库
                        crnProtocol.setLastIo("I");
                    }
                }
                // 如果最近一次是出库模式
                else if (crnProtocol.getLastIo().equals("O")) {
                    if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrnStn(crn, crnProtocol); //  出库
                        crnProtocol.setLastIo("I");
                    } else if (basCrnp.getInEnable().equals("Y")) {
                        this.crnStnToLoc(crn, crnProtocol); //  入库
                        crnProtocol.setLastIo("O");
                    }
                }
            }else if (extProtocol.isPut()){//允许放

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

        }
    }

    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                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（设备上走）的入库工作档
                TaskWrk taskWrk = taskWrkMapper.selectPakIn(slave.getId(), staProtocol.getWorkNo().intValue(), staDesc.getStnNo().toString());
                if(null == taskWrk) {
                    continue;
                }

                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

                // 已经存在吊车执行任务时，则过滤
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }

                //取出命令
                List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
                Integer commandStep = taskWrk.getCommandStep();
                if (commandInfos.isEmpty()) {
                    continue;//命令空
                }
                CommandInfo commandInfo = commandInfos.get(commandStep);
                CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
                CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);

                if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 2.设备上走 => 3.吊车入库中
                    Date now = new Date();
                    taskWrk.setWrkSts(3);
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
                }

//                // 命令下发区 --------------------------------------------------------------------------
//                CrnCommand crnCommand = new CrnCommand();
//                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
//                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
//                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
//                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
//                crnCommand.setSourcePosX(crnStn.getBay().shortValue());     // 源库位列
//                crnCommand.setSourcePosY(crnStn.getLev().shortValue());     // 源库位层
//                crnCommand.setSourcePosZ(crnStn.getRow().shortValue());     // 源库位排
//                crnCommand.setDestinationPosX(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
//                crnCommand.setDestinationPosY(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
//                crnCommand.setDestinationPosZ(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位排
//                crnCommand.setCommand((short)1);
//                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
//                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
//                } else {
//                    // 修改工作档状态 2.设备上走 => 3.吊车入库中
//                    Date now = new Date();
//                    taskWrk.setWrkSts(3);
//                    taskWrk.setModiTime(now);
//                    if (taskWrkMapper.updateById(taskWrk) == 0) {
//                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
//                    }
//                }
            }

            return;
        }
    }

    /**
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
        if (taskWrksInitial.size()==0){
            return;
        }
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs){
                // 获取工作状态为11（生成出库ID）的出库工作档
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(),staDesc.getStnNo().toString());
                for (TaskWrk taskWrk : taskWrks){
                    if (taskWrk == null) {
                        continue;
                    }
                    // 工作档状态判断
                    if (taskWrk.getIoType() != 2 || taskWrk.getTargetPoint() == null || taskWrk.getStartPoint() == null) {
                        log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getStartPoint(), taskWrk.getIoType());
                        continue;
                    }
                    // 获取堆垛机出库站信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
    public synchronized void DevpTaskAndPut() throws InterruptedException {
        try {
            for (DevpSlave devp : slaveProperties.getDevp()) {
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        break;
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }

                    // 查询站点详细信息
                    BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                    if (staDetl == null) {
                        log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                        break;
//                    System.out.println(JSON.toJSONString(staProtocol));
                    if (staProtocol.isAutoing()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),2,1);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }
                    }else if (staProtocol.isLoading()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),2,3);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }
                    }else if (staProtocol.isInEnable()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),2,5);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }
                    }else if (staProtocol.isOutEnable()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),2,7);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }
                    }

                    // 判断堆垛机出库站状态
                    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) {
                            break;
                    if (staProtocol.isEmptyMk()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),1,10);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }

                        // 已经存在吊车执行任务时，则过滤
                        if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                            break;
                    }
                    if (staProtocol.isFullPlt()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),3,10);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }

                        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                        if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {

                            taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());

                            List<TaskWrk> taskWrks1 = taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
                            if (Cools.isEmpty(taskWrks1) && taskWrks1.size()!=0){
                                continue;
                            }
                            String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
                            TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
                            if (!Cools.isEmpty(hallowLocNoTask)){
                                if (!Cools.isEmpty(hallowLocNoTask.getTargetPoint())){
                                    continue;
                                }
//                            new PostMesDataUtils().postMesData("移库任务分配库位",wmsUrl,movePath,hallowLocNoTask);
                                try {
                                    String response = new HttpHandler.Builder()
                                            .setUri(wmsUrl)
                                            .setPath(movePath)
                                            .setJson(JSON.toJSONString(hallowLocNoTask))
                                            .build()
                                            .doPost();
                                    System.out.println("response:"+response);
                                    JSONObject jsonObject = JSON.parseObject(response);
                                    if (jsonObject.getInteger("code").equals(200)) {
                                        //解析
                                    }
                                }catch (Exception e){
                                    log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/"+movePath, JSON.toJSONString(hallowLocNoTask), "请求移库任务分配库位");
                                }
                                continue;
                            }
                    }
                    if (staProtocol.isCar()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),5,10);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }

                        //取出命令
                        List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
                        Integer commandStep = taskWrk.getCommandStep();
                        if (commandInfos.isEmpty()) {
                            continue;//命令空
                    }
                    if (staProtocol.isLow()){
                        WrkMastSta wrkMastSta = new WrkMastSta(new Date(),7,10);
                        Integer count = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts",3).eq("wrk_no", wrkMastSta.getWrkNo()));
                        if (count==0){
                            wrkMastSta.setType(1);
                            wrkMastSta.setWrkType(3);
                            wrkMastStaMapper.insert(wrkMastSta);
                        }
                        CommandInfo commandInfo = commandInfos.get(commandStep);
                        CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
                        CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);

                        if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                            Date now = new Date();
                            taskWrk.setWrkSts(12);
                            taskWrk.setModiTime(now);
                            if (taskWrkMapper.updateById(taskWrk) == 0) {
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                            }
                        }
                        return;
                    }
                }
            }
        } catch (Exception e) {
            log.error("生成小车搬运任务  ===>> 失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    /**
     * 库位移转
     * 执行小车搬运任务
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的移库工作档
            List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut3(slave.getId(), crnStn.getStaNo().toString());
            for (TaskWrk taskWrk : taskWrks){
                if (taskWrk == null || Cools.isEmpty(taskWrk.getTargetPoint()) || taskWrk.getTargetPoint().equals("")) {
                    continue;
                }
                // 工作档状态判断
                if (taskWrk.getIoType() != 3 || taskWrk.getTargetPoint() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/目标库位号, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
                    continue;
    public synchronized void rgvRunWrkMastFullSta() {
        try{
            SiemensRgvThread rgvThread = (SiemensRgvThread) SlaveConnection.get(SlaveType.Rgv, 1);
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                log.error("RGV不在线");
                return;
            }
            // 只有当RGV空闲、自动,工位一无物//rgv可用
            if (rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getLoaded1()==0
                    && rgvProtocol.getTaskNo1() == 0
                    && rgvThread.isPakMk()
            ) {
                Integer selectCount = wrkMastStaMapper.selectCount(new EntityWrapper<WrkMastSta>().ne("wrk_sts", 3).ne("wrk_sts", 0));
                if (selectCount>0){
                    log.error("存在执行RGV中任务，但是小车状态空闲！！！");
                    return;
                }

                // 命令下发区 --------------------------------------------------------------------------

                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

                // 已经存在吊车执行任务时，则过滤
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }


                // 1.堆垛机开始移动
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getRowShort(taskWrk.getStartPoint()));     // 源库位排
                crnCommand.setSourcePosY(Utils.getBayShort(taskWrk.getStartPoint()));     // 源库位列
                crnCommand.setSourcePosZ(Utils.getLevShort(taskWrk.getStartPoint()));     // 源库位层
                crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                    Date now = new Date();
                    taskWrk.setWrkSts(12);
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectList(new EntityWrapper<WrkMastSta>().eq("wrk_sts",0));
                for (WrkMastSta wrkMastSta : wrkMastStaList){
                    if (wrkMastSta.getType()!=1 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                        continue;
                    }
                    boolean sign = rgvTakeFullAll(1, wrkMastSta); //命令下发
                    if (sign){
                        wrkMastSta.setWrkSts(1);
                        wrkMastSta.setUpdateTime(new Date());
                        wrkMastStaMapper.updateById(wrkMastSta);
                    } else {
                        log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                    }
                    break;
                }
                return;
            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
        }

    }

    /**
     * 执行对工作档的完成操作
     */
    @Async
    public void storeFinished() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {

                //获取指令ID
                Integer commandId = crnProtocol.getCommandId();
                CommandInfo commandInfo = commandInfoService.selectById(commandId);
                if (commandInfo == null) {
                    //指令不存在
                    continue;
                }

                commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//指令完成
                commandInfo.setCompleteTime(new Date());//指令完成时间
                if (commandInfoService.updateById(commandInfo)) {//修改成功后复位堆垛机
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
                }
    /*
     * 小车取货至工位任务
     * */
    public synchronized boolean rgvTakeFullAll(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().intValue()); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
            rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
            rgvCommand.setCommand((short) 0);   //工位1任务确认
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

//    /**
//     * 执行对工作档的完成操作
//     */
//    @Async
//    public void storeFinished() {
//        for (CrnSlave crn : slaveProperties.getCrn()) {
//            // 获取堆垛机信息
//            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
//            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
//            if (crnProtocol == null) { continue; }
//            //  状态：等待确认 并且  任务完成位 = 1
//            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
//                // 获取入库待确认工作档
//                TaskWrk taskWrk = taskWrkMapper.selectCrnNoWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
//                if (Cools.isEmpty(taskWrk)) {
//                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
//                    continue;
//                }
//                // 入库 + 库位转移  ==> 4.入库完成
//                if ((taskWrk.getWrkSts() == 3 && taskWrk.getIoType() == 1) || (taskWrk.getWrkSts() == 12 && taskWrk.getIoType() == 3)) {
//                    taskWrk.setWrkSts(4);
//                } else {
//                    continue;
//                }
//                Date now = new Date();
//                taskWrk.setModiTime(now);
//                Integer integerTaskWrk = taskWrkMapper.updateById(taskWrk);
//                // 修改成功后复位堆垛机
//                if (integerTaskWrk > 0) {
//                    // 堆垛机复位
//                    crnThread.setResetFlag(true);
//
//                    //更新库位状态
//                    LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
//                    locMast.setLocSts("F");//F.在库
//                    locMast.setBarcode(taskWrk.getBarcode());//托盘码
//                    locMast.setModiTime(now);
//                    locMast.setModiUser(9999L);
//                    locMastService.updateById(locMast);
//                }
//            }
//        }
//    }

    /**
     * 堆垛机异常信息记录
     */
    @Async
    public void recCrnErr(){
    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;
            SiemensRgvThread rgvThread = (SiemensRgvThread) SlaveConnection.get(SlaveType.Rgv, 1);
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                return;
            }
            if (true) {
//            if (crnProtocol.getModeType() != CrnModeType.STOP) {
                // 有任务
                if (crnProtocol.getTaskNo() != 0) {
                    BasErrLog latest = basErrLogService.findLatestByTaskNo(crn.getId(), crnProtocol.getTaskNo().intValue());
                if (rgvProtocol.getTaskNo1() != 0) {

                    BasErrLog latest = basErrLogService.findLatestByTaskNo(1, rgvProtocol.getTaskNo1());
                    // 有异常
                    if (latest == null) {
                        if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm1() > 0) {
                            WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
                            if (wrkMast == null) {
                                continue;
                        if (rgvProtocol.getAlarm() != null && rgvProtocol.getAlarm() > 0) {
                            WrkMastSta wrkMastSta = wrkMastStaService.selectOne(new EntityWrapper<WrkMastSta>()
                                    .setSqlSelect("TOP 1 wrk_no as wrkNo , wrk_sts as wrkSts,wrk_start as wrkStart,wrk_end as wrkEnd, create_time as createTime")
                                    .eq("wrk_No", rgvProtocol.getTaskNo1())
                                    .orderBy("create_time", false)

                            );
                            if (wrkMastSta == null) {
                               return;
                            }
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm1());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm1()):crnError.getErrName();
                            BasRgvErr rgvErr = basRgvErrService.selectById(rgvProtocol.getAlarm());
                            String errName = rgvErr == null ? String.valueOf(rgvProtocol.getAlarm()) : rgvErr.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    wrkMast.getWrkNo(),    // 工作号
                                    wrkMastSta.getWrkNo().intValue(),    // 工作号
                                    now,    // 发生时间
                                    null,    // 结束时间
                                    wrkMast.getWrkSts(),    // 工作状态
                                    wrkMast.getIoType(),    // 入出库类型
                                    crn.getId(),    // 堆垛机
                                    wrkMastSta.getWrkSts().longValue(),    // 工作状态
                                    wrkMastSta.getType(),    // 入出库类型
                                    1,    // 堆垛机
                                    null,    // plc
                                    wrkMast.getLocNo(),    // 目标库位
                                    wrkMast.getStaNo(),    // 目标站
                                    wrkMast.getSourceStaNo(),    // 源站
                                    wrkMast.getSourceLocNo(),    // 源库位
                                    wrkMast.getBarcode(),    // 条码
                                    (int) crnProtocol.getAlarm1(),    // 异常码
                                    null,    // 目标库位
                                    wrkMastSta.getWrkEnd(),    // 目标站
                                    wrkMastSta.getWrkEnd(),    // 源站
                                    null,    // 源库位
                                    null,    // 条码
                                    (int) rgvProtocol.getAlarm(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -735,29 +607,31 @@
                                    "任务中异常"    // 备注
                            );
                            if (!basErrLogService.insert(basErrLog)) {
                                log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);

                            }
                        }
                    } else {
                        // 异常修复
                        if (crnProtocol.getAlarm1() == null || crnProtocol.getAlarm1() == 0) {
                        if (rgvProtocol.getAlarm() == null || rgvProtocol.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());
                    BasErrLog latest = basErrLogService.findLatest(1);

                    // 有异常
                    if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm1() > 0) {
                    if (rgvProtocol.getAlarm() != null && rgvProtocol.getAlarm() > 0) {

                        // 记录新异常
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm1().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm1());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm1()):crnError.getErrName();
                        if (latest == null || (latest.getErrCode() != rgvProtocol.getAlarm().intValue())) {
                            BasRgvErr rgvErr = basRgvErrService.selectById(rgvProtocol.getAlarm());
                            String errName = rgvErr == null ? String.valueOf(rgvProtocol.getAlarm()) : rgvErr.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    null,    // 工作号
@@ -765,14 +639,14 @@
                                    null,    // 结束时间
                                    null,    // 工作状态
                                    null,    // 入出库类型
                                    crn.getId(),    // 堆垛机
                                    1,    // 堆垛机
                                    null,    // plc
                                    null,    // 目标库位
                                    null,    // 目标站
                                    null,    // 源站
                                    null,    // 源库位
                                    null,    // 条码
                                    (int)crnProtocol.getAlarm1(),    // 异常码
                                    (int) rgvProtocol.getAlarm(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -782,10 +656,10 @@
                                    "无任务异常"    // 备注
                            );
                            if (!basErrLogService.insert(basErrLog)) {
                                log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);

                            }
                        }
                    // 无异常
                        // 无异常
                    } else {
                        // 异常修复
                        if (latest != null && latest.getStatus() == 1) {
@@ -793,85 +667,17 @@
                            latest.setUpdateTime(now);
                            latest.setStatus(2);
                            if (!basErrLogService.updateById(latest)) {
                                log.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());

                            }
                        }
                    }
                }
            }

        }

//        News.infoNoLog(""+mark+" - 0"+" - 堆垛机异常信息记录执行完成");
    }

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

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

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

    //自动完成任务
    public synchronized void autoCompleteTask() {
        List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
        for (TaskWrk taskWrk : taskWrks) {
            //获取命令集合
            List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
            if (taskWrk.getCommandStep() != commandInfos.size()) {
                continue;//当前步序没有到达最后一条命令
            }

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

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

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

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


}