#演示

zjj

2024-04-20 d8b7de110ce5e16b95f87f79aec65c13b7f475f2

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

@@ -1,298 +1,366 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.StaDesc;
import com.zy.asrs.entity.WaitPakin;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.mapper.WaitPakinMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.StaDescService;
import com.zy.asrs.service.WrkDetlService;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
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.core.Slave;
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.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.CrnStatusType;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.Task;
import com.zy.core.enums.*;
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.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.CrnThread;
import com.zy.core.thread.DevpThread;
import com.zy.core.thread.LedThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.core.thread.SiemensRgvThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.Date;
import java.util.List;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 立体仓库WCS系统主流程业务
 * Created by vincent on 2020/8/6
 */
@Slf4j
@Service("mainService")
@Transactional
public class MainServiceImpl {

    public static final long COMMAND_TIMEOUT = 5 * 1000;

    @Autowired
    private CommonService commonService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private WrkMastMapper wrkMastMapper;
    private WrkMastStaMapper wrkMastStaMapper;
    @Autowired
    private WrkDetlService wrkDetlService;
    private FillingMastService fillingMastService;
    @Autowired
    private WaitPakinMapper waitPakinMapper;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    private VacuumMastService vacuumMastService;

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

    public Integer wrkNo1 = 10000;

    public Integer wrkNo2 = 20000;



    /**
     * 入库站，根据条码扫描生成入库工作档，工作状态 2
     * 堆垛机演示  ===>> 库位移转
     */
    @Transactional
    public void generateStoreWrkFile() {
        // 根据输送线plc遍历
    public void getRgvTask() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                // 获取条码
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                String barcode = barcodeThread.getBarcode();
                // 获取入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInreq1()
                        && !staProtocol.isEmptyMk() && staProtocol.isInreq1() && staProtocol.getWorkNo() ==0
                        && staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {
                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    if (wrkMast != null) {
                        log.warn("工作档中已存在该站状态为1的数据,工作号-{}", wrkMast.getWrkNo());
                for (RgvSlave rgv : slaveProperties.getRgv()) {
                    if (!rgv.getDemo()){
                        continue;

                    }
                    // 获取入库通知档
                    List<WaitPakin> waitPakins = waitPakinMapper.selectList(new EntityWrapper<WaitPakin>().eq("barcode", barcode));
                    // 工作号
                    int workNo = commonService.getWorkNo(0);
                    // 检索库位
                    List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
                    StartupDto startupDto = commonService.getLocNo(1, 1, inSta.getStaNo(), matNos);
                    String locNo = startupDto.getLocNo();
                    if (!waitPakins.isEmpty()) {
                        // 插入工作明细档
                        wrkDetlService.createWorkDetail(workNo, waitPakins, barcode);
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        log.warn("无此入库条码数据---{}", barcode);
                        continue;
                        staProtocol = staProtocol.clone();
                    }

                    // 插入工作主档
                    wrkMast = new WrkMast();
                    wrkMast.setWrkNo(workNo);
                    wrkMast.setIoTime(new Date());
                    wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
                    wrkMast.setIoType(1); // 入出库状态：1.入库
                    wrkMast.setIoPri(10D); // 优先级：10
                    wrkMast.setCrnNo(startupDto.getCrnNo());
                    wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
                    wrkMast.setStaNo(startupDto.getStaNo());
                    wrkMast.setLocNo(startupDto.getLocNo());
                    wrkMast.setBarcode(barcode); // 托盘码
                    wrkMast.setFullPlt("Y"); // 满板：Y
                    wrkMast.setPicking("N"); // 拣料
                    wrkMast.setExitMk("N"); // 退出
                    wrkMast.setEmptyMk("N"); // 空板
                    wrkMast.setLinkMis("N");
//                    wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
                    // 操作人员数据
                    wrkMast.setAppeTime(new Date());
                    wrkMast.setModiTime(new Date());
                    Integer insert = wrkMastMapper.insert(wrkMast);
                    if (insert == 0) {
                        throw new CoolException("保存工作档失败");
                    }
                    // 更新目标库位状态
                    LocMast locMast = locMastService.selectById(startupDto.getLocNo());
                    locMast.setLocSts("S"); // S.入库预约
                    locMast.setModiTime(new Date());
                    if (!locMastService.updateById(locMast)){
                        throw new CoolException("改变库位状态失败");
                    }

                    // 更新站点信息 且 下发plc命令
                    barcodeThread.setBarcode("");
                    staProtocol.setWorkNo(workNo);
                    staProtocol.setStaNo(startupDto.getStaNo());
                    staProtocol.setPakMk(false);
                    staProtocol.setInreq1(false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task<>(4, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败");
                    }

                }


            }
        }

    }


    /**
     * 拣料、并板、盘点再入库
     */
    public void stnToCrnStnPick(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
            for (DevpSlave.Sta pickSta : devp.getPickSta()) {
                // 获取拣料入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInreq1()
                    && staProtocol.getWorkNo() > 0 && staProtocol.isPakMk()){
                    WrkMast wrkMast = wrkMastMapper.selectPickStep(staProtocol.getWorkNo());
                    if (wrkMast == null) {
                        // 无拣料数据
                        continue;
                    }
                    if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 1070)
                        || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
                        continue;
                    }
                    // 保存工作明细档历史档
                    if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                        throw new CoolException("保存工作明细档历史档失败");
                    }
                    // 保存工作主档历史档
                    if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                        throw new CoolException("保存工作主档历史档失败");
                    }
                    // 获取目标站
                    Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                            .eq("type_no", wrkMast.getIoType() - 50)
                            .eq("stn_no", wrkMast.getStaNo()) // 作业站点 = 拣料出库的目标站
                            .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
                    StaDesc staDesc = staDescService.selectOne(wrapper);
                    if (Cools.isEmpty(staDesc)) {
                        throw new CoolException("入库路径不存在");
                    }
                    // 堆垛机站点(目标站)
                    Integer staNo = staDesc.getCrnStn();
                    // 更新工作档数据状态
                    wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                    wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                    wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
                    wrkMast.setStaNo(staNo); // 目标站
                    wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
                    wrkMast.setSourceLocNo(""); // 源库位清空
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        throw new CoolException("更新工作档数据状态失败");
                    }
                    // 修改库位状态 Q.拣料/盘点/并板再入库
                    LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                    locMast.setLocSts("Q");
                    locMast.setModiTime(new Date());
                    if (!locMastService.updateById(locMast)) {
                        throw new CoolException("修改库位状态失败");
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo(wrkMast.getStaNo());
                    staProtocol.setPakMk(false);
                    staProtocol.setInreq1(false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task<>(4, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败");
                    }

                }

            }

        }
    }

    /**
     * 堆垛机站出库到出库站
     */
    public void crnStnToOutStn() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
            for (DevpSlave.Sta outSta : devp.getOutSta()) {
                // 获取堆垛机出库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(outSta.getStaNo());
                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(staProtocol.getSiteId());
                    if (wrkMast == null) {
                        continue;
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                    CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
                    CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                    if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                        // 移动中
                        continue;
                    }
                    // 更新工作档状态为14失败 todo:luxiaotao
                    if (crnProtocol.mode == 3 && crnProtocol.getTaskNo() == wrkMast.getWrkNo()
                            && crnProtocol.statusType == CrnStatusType.IDLE
                            && crnProtocol.forkPos==0) {
                        wrkMast.setWrkSts(14L);
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            throw new CoolException("更新工作档的工作状态为14失败，工作号"+wrkMast.getWrkNo());
                    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);
                        }
                    }

                    // 更新堆垛机信息 且 下发plc命令 todo:luxiaotao
                    crnProtocol.setStatus(CrnStatusType.IDLE);
                    crnProtocol.setTaskNo((short)0);
                    boolean result = MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task<>(4, crnProtocol));
                    if (!result) {
                        throw new CoolException("更新堆垛机信息失败");
                    }

                }

            }
        }
    }
    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 void storeFinished() {
        for (Slave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                    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);
                }

            }

        }
    }

    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;
        }
    }



}