*

lsh

2024-10-21 632c1351c9f0ba96d1f43e46aed2bcbd4a50e7d6

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

@@ -1,162 +1,248 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.LocMast;
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.WrkDetlService;
import com.zy.common.model.StartupDto;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.BasCircularShuttleService;
import com.zy.asrs.service.BasDevpPositionService;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.SortTheExecutionOfTheCarUtil;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.DevpSlave;
import com.zy.core.enums.*;
import com.zy.core.model.RgvSlave;
import com.zy.core.model.Task;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.model.command.RgvCommand;
import com.zy.core.model.protocol.RgvProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.DevpThread;
import com.zy.core.thread.RgvThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

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

    @Autowired
    private CommonService commonService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private WrkMastMapper wrkMastMapper;
    private BasDevpService basDevpService;
    @Autowired
    private WrkDetlService wrkDetlService;
    private BasRgvServiceImpl basRgvService;
    @Autowired
    private WaitPakinMapper waitPakinMapper;
    private BasDevpPositionService basDevpPositionService;
    @Autowired
    private LocMastService locMastService;
    private BasCircularShuttleService basCircularShuttleService;
    @Autowired
    private JdbcTemplate jdbcTemplate;

    private WrkMastService wrkMastService;
    /**
     * 入库站，根据条码扫描生成入库工作档，工作状态 2
     * 站点任务检测  更新小车位置信息
     */
    @Transactional
    public void generateStoreWrkFile() {
        // 根据输送线plc遍历
        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());
                        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);
                    } else {
                        log.warn("无此入库条码数据---{}", barcode);
                        continue;
                    }

                    // 插入工作主档
                    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 synchronized void updateStePosition() {
        try{
            boolean sign = false;
            Integer rgvNo = 0;
            List<BasCircularShuttle> basCircularShuttleList = basCircularShuttleService.selectList(new EntityWrapper<BasCircularShuttle>().orderBy("rgv_id", true));
            for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    sign = true;
                } else if (rgvProtocol.modeType != RgvModeType.AUTO || (rgvProtocol.getStatusType() != RgvStatusType.IDLE && rgvProtocol.getStatusType() != RgvStatusType.ROAM) ){
                    sign = true;
                } else {
                    rgvNo = basCircularShuttle.getRgvNo();
                    break;
                }
            }
            if (sign && rgvNo!=0){
                int[][] ints = new int[basCircularShuttleList.size()][2];
                for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
                    ints[basCircularShuttle.getRgvNo()-1] = new int[]{basCircularShuttle.getRgvNo(),basCircularShuttle.getRgvId()};
                }
                String[] oldList = new String[ints.length];
                for (int[] rgv : ints){
                    oldList[rgv[0]-1] = Arrays.toString(rgv);
                }
                int[][] rgvList = SortTheExecutionOfTheCarUtil.ReorderSteId(ints, rgvNo);
                String[] newList = new String[rgvList.length];
                for (int[] rgv : rgvList){
                    newList[rgv[0]-1] = Arrays.toString(rgv);
                }


                log.info("更新小车排序信息：原始小车号rgvNo={},小车重新排序信息={},小车原始排序信息={}",rgvNo,Arrays.toString(newList),Arrays.toString(oldList));
                for (BasCircularShuttle basCircularShuttle : basCircularShuttleList){
                    int[] rgv = rgvList[basCircularShuttle.getRgvNo() - 1];
                    basCircularShuttle.setRgvId(rgv[1]);
                    basCircularShuttleService.updateById(basCircularShuttle);
                }
            }

        } catch (Exception e) {
            log.error("自动更新小车排序信息失败，异常："+e);
        }

    }


    /**
     * 拣料、并板、盘点再入库
     * 站点任务检测  下发小车取放任务
     */
    public void stnToCrnStnPick(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
            for (DevpSlave.Sta pickSta : devp.getPickSta()) {

    public synchronized void DevpTaskNoRun() {
        try{
            BasCircularShuttle basCircularShuttle = basCircularShuttleService.selectOne(new EntityWrapper<BasCircularShuttle>().eq("rgv_id", 1));
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                return;
            }

            List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("plc_position",false));
            Integer devNo = SortTheExecutionOfTheCarUtil.LatelyAndLessThan(basDevpPositions, rgvProtocol.getRgvPos());
            BasDevpPosition[] basDevpPositionsList = SortTheExecutionOfTheCarUtil.devpNoSort(basDevpPositions, devNo);
            BasDevpPosition[] basDevpPositionsListUN = SortTheExecutionOfTheCarUtil.devpNoSortUN(basDevpPositionsList);
            List<List<WrkMast>> wrkMastLists = getWrkMastLists(basDevpPositionsListUN);
            //下发任务
            taskDown(wrkMastLists);
        } catch (Exception e){
            log.error("自动下发小车取放任务失败，异常："+e);
        }
    }

    //获取小车取放任务列表失败
    public synchronized List<List<WrkMast>> getWrkMastLists(BasDevpPosition[] basDevpPositionsListUN) {
        List<List<WrkMast>> wrkMastLists = new ArrayList<>();
        try{
            List<WrkMast> wrkMastlistA = new ArrayList<>();
            List<WrkMast> wrkMastlistB = new ArrayList<>();
            for (BasDevpPosition basDevpPosition : basDevpPositionsListUN){
                WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("sta_no", basDevpPosition.getDevNo()).eq("wrk_sts",1L));
                if (!Cools.isEmpty(wrkMast)){
                    if (SortTheExecutionOfTheCarUtil.devpNoSortbj(basDevpPositionsListUN,wrkMast.getSourceStaNo(),wrkMast.getStaNo())){
                        wrkMastlistA.add(wrkMast);
                    } else {
                        wrkMastlistB.add(wrkMast);
                    }
                }
            }
            wrkMastLists.add(wrkMastlistA);
            wrkMastLists.add(wrkMastlistB);
            return wrkMastLists;
        } catch (Exception e){
            log.error("获取小车取放任务列表失败，异常："+e);
            return wrkMastLists;
        }
    }

    public synchronized void taskDown(List<List<WrkMast>> wrkMastLists) {
        long rgvId = 0;
        runRgv:
        for (List<WrkMast> wrkMastList : wrkMastLists){
            for (WrkMast wrkMast: wrkMastList){
                rgvId++;
                BasCircularShuttle basCircularShuttle = basCircularShuttleService.selectOne(new EntityWrapper<BasCircularShuttle>().eq("rgv_id", 1L));
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, basCircularShuttle.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol != null
                        && rgvProtocol.modeType == RgvModeType.AUTO
                        && (rgvProtocol.getStatusType() == RgvStatusType.IDLE || rgvProtocol.getStatusType() == RgvStatusType.ROAM)
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getAlarm() == 0){
                    RgvCommand rgvCommand = new RgvCommand();
                    rgvCommand.setRgvNo(rgvProtocol.getRgvNo());
                    rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue());
                    rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                    rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue());
                    rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
                    rgvCommand.setSourceStaNo1(wrkMast.getSourceStaNo().shortValue());   //工位1起点
                    rgvCommand.setDestinationStaNo1(wrkMast.getStaNo().shortValue());   //工位1目标站点
                    rgvCommand.setCommand((short) 1);   //工位1任务确认
                    if (!MessageQueue.offer(SlaveType.Rgv, rgvProtocol.getRgvNo(), new Task(2, rgvCommand))) {
                        //
                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                        break runRgv;
                    }
                    wrkMast.setWrkSts(2L);
                    wrkMast.setRgvNo(rgvProtocol.getRgvNo());
                    wrkMast.setAppeTime(new Date());
                    try{
                        wrkMastService.updateById(wrkMast);
                        continue ;
                    }catch (Exception e){
                        log.error("更新小车任务失败,任务号："+wrkMast.getWrkNo());
                    }
                    break runRgv;
                } else {
                    break runRgv;
                }
            }
        }
    }

    //任务完成
    public synchronized void rgvCompleteWrkMastSta() {
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV等待WCS确认、自动
                if (rgvProtocol.getStatusType() == RgvStatusType.WAITING
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getTaskNo1()!=0
                ) {
                    log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", rgvProtocol.getTaskNo1().longValue()));
                    if (Cools.isEmpty(wrkMast) || !wrkMast.getWrkSts().equals(2L)){
                        log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMast);
                        continue;
                    }
                    boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                    if (!rgvComplete){
                        log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                        break;
                    }
                    wrkMast.setWrkSts(3L);
                    wrkMast.setAppeTime(new Date());
                    wrkMastService.updateById(wrkMast);
                }
            }
        } catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }

    /*
     * 小车复位
     * */
    public synchronized boolean rgvComplete(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(3, new RgvCommand()))) {
                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;
        }
    }
}