#

luxiaotao1123

2022-11-01 4e31f32d04c9826e2fac777dd679286f6dd5ac95

#

 src/main/java/com/zy/asrs/mapper/WrkChargeMapper.java

@@ -3,14 +3,15 @@
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.zy.asrs.entity.WrkCharge;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface WrkChargeMapper extends BaseMapper<WrkCharge> {

    WrkCharge selectWorking(Integer steNo);
    WrkCharge selectWorkingOfCharge(@Param("steNo") Integer steNo);


    WrkCharge selectWorkingOfReset(@Param("steNo") Integer steNo);

}

 src/main/java/com/zy/asrs/service/WrkChargeService.java

@@ -5,8 +5,6 @@

public interface WrkChargeService extends IService<WrkCharge> {

    WrkCharge selectWorking(Integer steNo);


    WrkCharge selectWorking(Integer steNo, String memo);

}

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

@@ -1665,6 +1665,34 @@
                                    log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 42) {
                            // 42.吊车搬运 ===>> 43.小车到达
                            wrkCharge.setWrkSts(43L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改复位任务状态 42.吊车搬运 ===>> 43.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 46) {
                            // 46.放至待机位 ===>> 47.复位成功
                            wrkCharge.setWrkSts(47L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改复位任务状态 46.放至待机位 ===>> 47.复位成功 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        }
                    }

@@ -1906,6 +1934,14 @@
                                wrkCharge.setWrkSts(37L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }  else if (wrkCharge.getWrkSts() == 44) {
                                // 44.小车走行 ===>> 45.小车待搬
                                wrkCharge.setWrkSts(45L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改演示任务状态 44.小车走行 ===>> 45.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
@@ -2473,7 +2509,7 @@
                if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                WrkCharge wrkCharge = wrkChargeService.selectWorking(null);
                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, "charge");

                if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
                    // 寻找空闲充电桩
@@ -2640,7 +2676,7 @@
                            crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(2, crnCommand))) {
                            if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
                                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
                            } else {
                                // 修改穿梭车运行中排列层
@@ -2683,7 +2719,7 @@
     */
    public synchronized void steFromChargeToIdleLoc() {
        // 与充电任务不同步进行
        if (null != wrkChargeService.selectWorking(null)) { return; }
        if (null != wrkChargeService.selectWorking(null, "charge")) { return; }
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        // 检索充电桩
        for (SteChargeType value : SteChargeType.values()) {
@@ -2719,22 +2755,27 @@
                    && steProtocol.getCharge() < Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                // 开始穿梭车复位任务
                WrkCharge wrkCharge = new WrkCharge();
                wrkCharge.setSteNo(steNo);
                wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
                wrkCharge.setWrkSts(41L);   // 41.小车准备复位
                wrkCharge.setCrnNo(2);  // 固定2号堆垛机
                wrkCharge.setIoPri((double) 10);
                wrkCharge.setSourceLocNo(value.locNo);
                wrkCharge.setLocNo(basSte.getIdleLoc());
                wrkCharge.setMemo("reset");
                if (!wrkChargeService.insert(wrkCharge)) {
                    log.error("保存{}号穿梭车复位任务失败!!!", steNo);
                    continue;

                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, "reset");

                if (wrkCharge == null) {
                    // 开始穿梭车复位任务
                    wrkCharge = new WrkCharge();
                    wrkCharge.setSteNo(steNo);
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
                    wrkCharge.setWrkSts(41L);   // 41.小车准备复位
                    wrkCharge.setCrnNo(2);  // 固定2号堆垛机
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setSourceLocNo(value.locNo);
                    wrkCharge.setLocNo(basSte.getIdleLoc());
                    wrkCharge.setMemo("reset");
                    if (!wrkChargeService.insert(wrkCharge)) {
                        log.error("保存{}号穿梭车复位任务失败!!!", steNo);
                        continue;
                    }
                }

                // 1.搬运至固定通道
                // 搬运至固定通道
                if (wrkCharge.getWrkSts() == 41L) {
                    // 搬小车至小车走向通道
                    List<String> channel = slaveProperties.getChannel();
@@ -2764,18 +2805,18 @@
                                crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), false).shortValue());     // 目标库位排
                                crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue());     // 目标库位列
                                crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue());     // 目标库位层
                                if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                                if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
                                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                                } else {
                                    // 修改穿梭车运行中排列层
                                    steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
                                    steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), false), channelLoc.getBay1(), channelLoc.getLev1());
                                    // 修改工作档状态 41.小车准备复位 => 42.吊车搬运
                                    Date now = new Date();
                                    wrkCharge.setWrkSts(42L);
                                    wrkCharge.setCrnStrTime(now);
                                    wrkCharge.setModiTime(now);
                                    if (!wrkChargeService.updateById(wrkCharge)) {
                                        log.error("修改工作档状态 41.小车准备复位 => 42.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                                        log.error("修改复位任务状态 41.小车准备复位 => 42.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                                    }
                                }
                                break;
@@ -2783,7 +2824,72 @@

                        }
                    }
                } else if (wrkCharge.getWrkSts() == 43L) {
                    // 小车行驶通道
                    if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                        steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.BACK_ORIGIN);  // 去左端

                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());
                        steCommand.setBay(steProtocol.getBay());
                        steCommand.setLev(steProtocol.getLev());
                        if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                        } else {
                            // 修改工作档状态 43.小车到达 ===> 44.小车走行
                            wrkCharge.setWrkSts(44L);
                            Date now = new Date();
                            wrkCharge.setCrnEndTime(now);
                            wrkCharge.setModiTime(now);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改复位任务状态 43.小车到达 ===> 44.小车走行 失败！！，工作号={}", wrkCharge.getWrkNo());
                            }
                        }
                    }
                } else if (wrkCharge.getWrkSts() == 45L) {
                    LocMast idleLoc = locMastService.selectById(basSte.getIdleLoc());

                    Integer otherSte = existOtherSte(idleLoc.getLocNo(), wrkCharge.getSteNo());
                    if (null != otherSte) {
                        log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), idleLoc.getLocNo(), otherSte);
                    } else {
                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                        CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                        if (crnProtocol == null) { continue; }
                        // 只有当堆垛机空闲 并且 无任务时才继续执行
                        if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                            // 堆垛机命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                            crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getGroupRow(idleLoc.getLocNo(), true).shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(idleLoc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(idleLoc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改穿梭车运行中排列层
                                steThread.modifyPos(Utils.getGroupRow(idleLoc.getLocNo(), true), idleLoc.getBay1(), idleLoc.getLev1());
                                // 修改工作档状态 45.小车待搬 => 46.放至待机位
                                Date now = new Date();
                                wrkCharge.setWrkSts(46L);
                                wrkCharge.setCrnStrTime(now);
                                wrkCharge.setModiTime(now);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改工作档状态 45.小车待搬 => 46.放至待机位 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                        }

                    }
                }
            }
        }

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

@@ -10,7 +10,13 @@
public class WrkChargeServiceImpl extends ServiceImpl<WrkChargeMapper, WrkCharge> implements WrkChargeService {

    @Override
    public WrkCharge selectWorking(Integer steNo) {
        return this.baseMapper.selectWorking(steNo);
    public WrkCharge selectWorking(Integer steNo, String memo) {
        switch (memo) {
            case "charge":
                return this.baseMapper.selectWorkingOfCharge(steNo);
            case "reset":
                return this.baseMapper.selectWorkingOfReset(steNo);
        }
        return null;
    }
}

 src/main/resources/mapper/WrkChargeMapper.xml

@@ -29,7 +29,7 @@

    </resultMap>

    <select id="selectWorking" resultMap="BaseResultMap">
    <select id="selectWorkingOfCharge" resultMap="BaseResultMap">
        select top 1 *
        from asr_wrk_charge
        where 1=1
@@ -40,4 +40,15 @@
        and memo = 'charge'
    </select>

    <select id="selectWorkingOfReset" resultMap="BaseResultMap">
        select top 1 *
        from asr_wrk_charge
        where 1=1
        <if test="steNo != null">
            and ste_no = #{steNo}
        </if>
        and wrk_sts &lt; 47
        and memo = 'reset'
    </select>

</mapper>