充电逻辑

Junjie

2023-04-06 39a7c54ceffb921258ac0148f58ccea60da0c87e

充电逻辑

 src/main/java/com/zy/asrs/entity/WrkCharge.java

@@ -60,6 +60,13 @@
    private Integer crnNo;

    /**
     * 四向穿梭车
     */
    @ApiModelProperty(value= "四向穿梭车")
    @TableField("shuttle_no")
    private Integer shuttleNo;

    /**
     * 穿梭车
     */
    @ApiModelProperty(value= "穿梭车")

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

@@ -10,8 +10,9 @@
@Repository
public interface WrkChargeMapper extends BaseMapper<WrkCharge> {

    WrkCharge selectWorkingOfCharge(@Param("steNo") Integer steNo, @Param("charge") Integer charge);
    WrkCharge selectWorkingOfCharge(@Param("shuttleNo") Integer shuttleNo, @Param("charge") Integer charge);

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

    WrkCharge selectByWorkNo(@Param("workNo") Integer workNo);
}

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

@@ -1163,7 +1163,8 @@
            }

            //四向穿梭车状态为等待确认
            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id && shuttleProtocol.getTaskNo() != 0) {
            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
                    && shuttleProtocol.getTaskNo() != 0) {
                //将任务档标记为完成
                WrkMast wrkMast = wrkMastMapper.selectByWorkNo(shuttleProtocol.getTaskNo().intValue());
                if (wrkMast != null) {
@@ -1203,6 +1204,48 @@
                }

            }

            //四向穿梭车状态为充电状态
            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.CHARGING_WAITING.id  //充电标识
                    && shuttleProtocol.getTaskNo() != 0) {
                //查询是否有充电任务
                WrkCharge wrkCharge = wrkChargeMapper.selectByWorkNo(shuttleProtocol.getTaskNo().intValue());
                if (wrkCharge != null) {
                    switch (wrkCharge.getWrkSts().intValue()) {
                        case 52://四向穿梭车迁移到提升机口
                            wrkCharge.setWrkSts(53L);//迁移完成
                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                            break;
                        case 56:
                            if (shuttleProtocol.getBatteryPower() == 1000) {
                                wrkCharge.setWrkSts(60L);//充电完成
                            }
                            break;
                        default:
                    }

                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        if (wrkCharge.getWrkSts() == 60) {
                            //设置四向穿梭车为空闲状态
                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                        }
                        //任务号清零
                        shuttleProtocol.setTaskNo((short) 0);
                        //源库位清零
                        shuttleProtocol.setSourceLocNo(null);
                        //目标库位清零
                        shuttleProtocol.setLocNo(null);
                        //标记复位
                        shuttleProtocol.setPakMk(true);
                        //任务指令清零
                        shuttleProtocol.setAssignCommand(null);
                        News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                    } else {
                        News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                    }
                }
            }

        }
    }

@@ -1283,7 +1326,7 @@

            commands.add(command2);//将命令添加进list

            //提升机搬运四向穿梭车
            //提升机前往目标楼层
            LiftCommand command3 = new LiftCommand();
            command3.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command3.setTaskNo(liftProtocol.getTaskNo());//任务号
@@ -1294,7 +1337,7 @@
            commands.add(command3);//将命令添加进list

            //提升机到达指定楼层，输送线将四向穿梭车移出去
            //输送线将四向穿梭车移动进来
            //输送线将四向穿梭车移动出去
            LiftCommand command4 = new LiftCommand();
            command4.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command4.setTaskNo(liftProtocol.getTaskNo());//任务号
@@ -1350,6 +1393,33 @@
                    }

                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        //设置提升机为空闲状态
                        liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
                        //任务号清零
                        liftProtocol.setTaskNo((short) 0);
                        //标记复位
                        liftProtocol.setPakMk(true);
                        //任务指令清零
                        liftProtocol.setAssignCommand(null);
                        //提升机解锁
                        liftProtocol.setLiftLock(false);
                        News.info("提升机已确认且任务完成状态,复位。提升机号={}", liftProtocol.getLiftNo());
                    } else {
                        News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
                    }
                }

                //查询是否有充电任务
                WrkCharge wrkCharge = wrkChargeMapper.selectByWorkNo(liftProtocol.getTaskNo().intValue());
                if (wrkCharge != null) {
                    switch (wrkCharge.getWrkSts().intValue()) {
                        case 54://提升机搬运中
                            wrkCharge.setWrkSts(55L);//提升机搬运完成
                            break;
                        default:
                    }

                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //设置提升机为空闲状态
                        liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
                        //任务号清零
@@ -3339,6 +3409,274 @@
    }

    /**
     * 四向穿梭车电量检测 ===>> 发起充电
     */
    public synchronized void loopShuttleCharge() {
        for (DevpSlave devpSlave : slaveProperties.getDevp()) {
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                //获取四向穿梭车线程
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
                ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                if (shuttleProtocol == null) {
                    continue;
                }

                //判断当前小车是否满足需要充电要求
                if (!shuttleProtocol.isRequireCharge()) {
                    continue;
                }

                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
                if (wrkCharge != null) {//已有充电任务
                    continue;
                }

                ShuttleChargeType shuttleCharge = null;
                String locNo;
                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                    switch (chargeType.id) {
                        case 1:
                            if (devpThread.charge0 == false) {
                                ShuttleChargeType first = ShuttleChargeType.FIRST;
                                locNo = first.locNo;
                                if (wrkChargeService.selectWorkingOfCharge(first.id) == null) {
                                    shuttleCharge = first;
                                }
                            }
                            break;
                        default:
                    }
                }

                if (shuttleCharge == null) {
                    continue;
                }

                String chargeLocNo = shuttleCharge.locNo;
                wrkCharge = new WrkCharge();
                wrkCharge.setShuttleNo(shuttle.getId());
                wrkCharge.setCharge(shuttleCharge.id);
                wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
                wrkCharge.setWrkSts(51L);   // 21.准备充电
                wrkCharge.setIoPri((double) 10);
                wrkCharge.setLocNo(chargeLocNo);
                wrkCharge.setMemo("charge");
                wrkCharge.setAppeTime(new Date());
                if (!wrkChargeService.insert(wrkCharge)) {
                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                    continue;
                }

                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);//充电中
                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
            }
        }


    }

    /**
     * 执行四向穿梭车充电任务
     */
    public synchronized void executeShuttleCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        if (wrkCharge == null) {
            return;
        }


        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
        if (shuttleThread == null) {
            return;
        }
        ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
        if (shuttleProtocol == null) {
            return;
        }

        //当前穿梭车库位号
        String currentLocNo = shuttleProtocol.getCurrentLocNo();
        //小车当前层高
        Integer currentLev = Integer.parseInt(currentLocNo.substring(currentLocNo.length() - 2, currentLocNo.length()));
        //获取提升机
        LiftSlave liftSlave = slaveProperties.getLift().get(0);
        //提升机库位号
        String liftLocNo = liftSlave.getLiftLocNo(currentLev);
        //充电库位号
        String chargeLocNo = wrkCharge.getLocNo();
        //充电库位层高
        Integer chargeLocNoLev = Integer.parseInt(chargeLocNo.substring(chargeLocNo.length() - 2, chargeLocNo.length()));

        if (wrkCharge.getWrkSts() == 51 || wrkCharge.getWrkSts() == 55) {
            if (currentLev == chargeLocNoLev) {
                //同一层无需经过提升机
                //直接计算车到充电库位
                //获取小车到充电库位路径指令
                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, chargeLocNo, ShuttleTaskModeType.PAK_IN.id);
                //进行充电中
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                assignCommand.setTaskMode((short) 9);//充电
                assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                assignCommand.setCharge(true);//充电任务

                //创建充电指令
                ShuttleCommand command = new ShuttleCommand();
                command.setCommandWord((short) 5);//充电
                command.setShuttleNo(shuttleProtocol.getShuttleNo());
                command.setChargeSwitch((short) 1);//开始充电
                command.setCommandEnd((short) 1);
                commands.add(command);

                //指令集分配
                assignCommand.setCommands(commands);

                wrkCharge.setWrkSts(56L);//充电中状态
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                    //下发任务
                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                }
            }else {
                //不同层，将目标库位分配成提升机库位号

                //小车移动到提升机口，计算路径
                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftLocNo, ShuttleTaskModeType.PAK_IN.id);
                //分配目标库位
                shuttleProtocol.setLocNo(liftLocNo);

                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                assignCommand.setTaskMode((short) 9);//充电
                assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                assignCommand.setCharge(true);//充电任务
                //目标库位
                assignCommand.setLocNo(liftLocNo);
                //源库位
                assignCommand.setSourceLocNo(currentLocNo);
                assignCommand.setCommands(commands);
                wrkCharge.setWrkSts(52L);//小车迁移状态
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                    //下发任务
                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                }
            }

        }else if(wrkCharge.getWrkSts() == 53){
            //小车已经达到提升机口
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
            if (liftThread == null) {
                return;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                return;
            }

            //判断提升机是否处于空闲状态
            if (!liftProtocol.isIdle()) {
                return;
            }

            //给提升机分配任务
            liftProtocol.setLiftLock(true);//锁定提升机
            liftProtocol.setTaskNo(wrkCharge.getWrkNo().shortValue());//设置任务号
            liftProtocol.setShuttleNo(wrkCharge.getShuttleNo().shortValue());//设置四向穿梭车号
            liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

            //命令list
            ArrayList<LiftCommand> commands = new ArrayList<>();

            //提升机当前楼层
            int liftLev = liftProtocol.getLev().intValue();
            if (liftLev != currentLev) {
                //穿梭车和提升机处于不同楼层
                LiftCommand command1 = new LiftCommand();
                command1.setLiftNo(liftProtocol.getLiftNo());//提升机号
                command1.setTaskNo(liftProtocol.getTaskNo());//任务号
                command1.setRun((short) 1);//升降
                command1.setDistPosition(currentLev.shortValue());//目标楼层(穿梭车所在楼层)
                command1.setLiftLock(true);//锁定提升机
                commands.add(command1);//将命令添加进list
            }

            //输送线将四向穿梭车移动进来
            LiftCommand command2 = new LiftCommand();
            command2.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command2.setTaskNo(liftProtocol.getTaskNo());//任务号
            command2.setRun((short) 6);//输送线运作
            command2.setLiftLock(true);//锁定提升机

            commands.add(command2);//将命令添加进list

            //提升机前往目标楼层
            LiftCommand command3 = new LiftCommand();
            command3.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command3.setTaskNo(liftProtocol.getTaskNo());//任务号
            command3.setRun((short) 1);//升降
            command3.setDistPosition(chargeLocNoLev.shortValue());//充电库位目标楼层
            command3.setLiftLock(true);//锁定提升机

            commands.add(command3);//将命令添加进list

            //提升机到达指定楼层，输送线将四向穿梭车移出去
            //输送线将四向穿梭车移动出去
            LiftCommand command4 = new LiftCommand();
            command4.setLiftNo(liftProtocol.getLiftNo());//提升机号
            command4.setTaskNo(liftProtocol.getTaskNo());//任务号
            command4.setRun((short) 3);//输送线运作
            command4.setLiftLock(true);//锁定提升机

            commands.add(command4);//将命令添加进list

            wrkCharge.setWrkSts(54L);//提升机搬运中
            //所需命令组合完毕，更新数据库，提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo());
            assignCommand.setTaskNo(liftProtocol.getTaskNo());
            if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
            }

        } else if (wrkCharge.getWrkSts() == 56) {
            //充电中
            //判断小车是否充满电量
            if (shuttleProtocol.getBatteryPower() == 1000) {
                //充满，断开充电
                List<ShuttleCommand> commands = new ArrayList<>();
                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                assignCommand.setTaskMode((short) 0);
                assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                assignCommand.setCharge(true);

                //创建充电指令
                ShuttleCommand command = new ShuttleCommand();
                command.setCommandWord((short) 5);//充电
                command.setShuttleNo(shuttleProtocol.getShuttleNo());
                command.setChargeSwitch((short) 2);//断开充电
                command.setCommandEnd((short) 1);
                commands.add(command);

                //指令集分配
                assignCommand.setCommands(commands);

                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
            }

            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.CHARGING_WAITING.id) {
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
            }
        }

    }

    /**
     * 小车电量检测 ===>> 发起充电
     */
    @SuppressWarnings("serial")

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

@@ -11,12 +11,12 @@
public class WrkChargeServiceImpl extends ServiceImpl<WrkChargeMapper, WrkCharge> implements WrkChargeService {

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

 src/main/java/com/zy/core/MainProcess.java

@@ -80,6 +80,9 @@
                    // 其他  ===>> LED显示器复位，显示默认信息
                    mainService.ledReset();
                    // 穿梭车 ===>> 小车电量检测充电
                    mainService.loopShuttleCharge();
                    mainService.executeShuttleCharge();
                    // 穿梭车 ===>> 小车电量检测充电
                    mainService.loopSteCharge();
                    mainService.executeSteCharge();
                    //出入库模式

 src/main/java/com/zy/core/enums/ShuttleChargeType.java

New file
@@ -0,0 +1,45 @@
package com.zy.core.enums;

import com.core.common.Cools;

public enum ShuttleChargeType {

    FIRST(1, "1800102"),
    ;

    ShuttleChargeType(int id, String locNo) {
        this.id = id;
        this.locNo = locNo;
    }

    public int id;

    public String locNo;

    public static ShuttleChargeType get(String locNo) {
        if (Cools.isEmpty(locNo)) {
            return null;
        }
        ShuttleChargeType[] values = ShuttleChargeType.values();
        for (ShuttleChargeType value : values) {
            if (value.locNo.equals(locNo)) {
                return value;
            }
        }
        return null;
    }

    public static ShuttleChargeType get(int id) {
        if (Cools.isEmpty(id)) {
            return null;
        }
        ShuttleChargeType[] values = ShuttleChargeType.values();
        for (ShuttleChargeType value : values) {
            if (value.id == id) {
                return value;
            }
        }
        return null;
    }

}

 src/main/java/com/zy/core/enums/ShuttleProtocolStatusType.java

@@ -8,6 +8,8 @@
    IDLE(1, "空闲"),
    WORKING(2, "作业中"),
    WAITING(3, "等待确认"),
    CHARGING(5, "充电中"),
    CHARGING_WAITING(6, "充电任务等待确认"),
    ;

    public Integer id;

 src/main/java/com/zy/core/model/command/ShuttleAssignCommand.java

@@ -28,6 +28,7 @@
     * 6： 右移
     * 7： 前移
     * 8： 后移
     * 9: 充电
     */
    private Short taskMode = 0;

@@ -51,4 +52,9 @@
     */
    private Boolean auto = true;

    /**
     * 是否为充电任务。true：是，false：否
     */
    private Boolean charge = false;

}

 src/main/java/com/zy/core/model/protocol/ShuttleProtocol.java

@@ -251,6 +251,27 @@
        }
    }

    // 是否满足充电状态
    public Boolean isRequireCharge() {
        boolean res = this.busyStatusType.equals(ShuttleStatusType.IDLE)
                && this.pakMk.equals(true)
                && this.errorCodeType.equals(ShuttleErrorCodeType.NORMAL)
                && this.taskNo == 0
                ;
        if (!res) {
            return res;
        } else {
            // 电量
            try {
                Integer chargeLine = SpringUtils.getBean(BasShuttleService.class).selectById(this.shuttleNo).getChargeLine();
                return this.getBatteryPower$() < chargeLine;
            } catch (Exception e) {
                News.error("fail", e);
                return false;
            }
        }
    }

    //通过当前二维码获取当前库位号
    public String getCurrentLocNo() {
        LocMastService locMastService = SpringUtils.getBean(LocMastService.class);

 src/main/java/com/zy/core/thread/LiftThread.java

@@ -416,6 +416,15 @@
                    News.info("提升机手动任务执行完成，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
                }

                //下发一条提升机解锁命令
                LiftCommand liftCommand = new LiftCommand();
                liftCommand.setRun((short) 0);
                liftCommand.setLiftNo(command.getLiftNo());
                liftCommand.setLiftLock(false);
                if (write(liftCommand)) {
                    News.info("提升机状态已解锁，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
                }

            }
        }


 src/main/java/com/zy/core/thread/ShuttleThread.java

@@ -528,8 +528,12 @@
                    }
                    News.info("四向穿梭车手动任务执行完成，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
                }else {
                    //对主线程抛出等待确认状态waiting
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
                    if (!assignCommand.getCharge()) {
                        //对主线程抛出等待确认状态waiting
                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
                    }else {
                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                    }
                    News.info("四向穿梭车任务执行完成等待确认中，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
                }


 src/main/resources/mapper/WrkChargeMapper.xml

@@ -27,6 +27,7 @@
        <result column="appe_time" property="appeTime" />
        <result column="memo" property="memo" />
        <result column="barcode" property="barcode" />
        <result column="shuttle_no" property="shuttleNo" />

    </resultMap>

@@ -34,13 +35,13 @@
        select top 1 *
        from asr_wrk_charge
        where 1=1
        <if test="steNo != null">
            and ste_no = #{steNo}
        <if test="shuttleNo != null">
            and shuttle_no = #{shuttleNo}
        </if>
        <if test="charge != null">
            and charge = #{charge}
        </if>
        and wrk_sts &lt; 30
        and wrk_sts &lt; 60
        and memo = 'charge'
        order by appe_time, io_pri desc
    </select>
@@ -57,4 +58,10 @@
        order by appe_time, io_pri desc
    </select>

    <select id="selectByWorkNo" resultMap="BaseResultMap">
        select top 1 * from asr_wrk_charge
        where wrk_no=#{workNo}
        order by appe_time, io_pri desc
    </select>

</mapper>