Merge branch 'rcs_master' into rcs_master_all_zkd

zhang

2 天以前 bd956ec24c5995e6a2a585d6a4987c6b7de372c1

 zy-acs-charge/src/main/java/com/zy/acs/charge/impl/AiPowerChargeServiceImpl.java

@@ -1,125 +1,393 @@
package com.zy.acs.charge.impl;

import com.github.xingshuangs.iot.protocol.modbus.service.ModbusRtuOverTcp;
import com.ghgande.j2mod.modbus.ModbusException;
import com.ghgande.j2mod.modbus.facade.ModbusTCPMaster;
import com.ghgande.j2mod.modbus.procimg.Register;
import com.ghgande.j2mod.modbus.procimg.SimpleRegister;
import com.ghgande.j2mod.modbus.util.BitVector;
import com.zy.acs.charge.ChargeCoreService;
import com.zy.acs.charge.constant.AiPowerChargerCoilEnum;
import com.zy.acs.charge.constant.AiPowerChargerRegisterEnum;
import com.zy.acs.charge.constant.AiPowerChargeCoilEnum;
import com.zy.acs.charge.constant.AiPowerChargeRegisterEnum;
import com.zy.acs.charge.constant.ChargerType;
import com.zy.acs.charge.model.ChargerStatus;
import com.zy.acs.common.utils.ByteUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 爱普拉AGV锂电智能充电机调度
 */
@Service
@Primary
@Service("aiPowerChargeService")
@Slf4j
public class AiPowerChargeServiceImpl implements ChargeCoreService {

public  class AiPowerChargeServiceImpl implements ChargeCoreService {

    @Override
    public boolean startCharging(ModbusRtuOverTcp client) {
    public ChargerType supportedType() {
        return ChargerType.Modbus;
    }

    /**
     * 开始充电
     *
     * @param client
     * @return
     */
    @Override
    public  boolean startCharging(ModbusTCPMaster client) {
        // AGV车报告到位 -> true
        client.writeCoil(AiPowerChargerCoilEnum.AGV_REPORTED_IN_POSITION.getAddr(), true);
        return true;
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            return client.writeCoil(AiPowerChargeCoilEnum.AGV_REPORTED_IN_POSITION.getAddr(), true);
        } catch (Exception e) {
            log.info("写入开始充电指令报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return false;
    }

    /**
     * 停止充电
     *
     * @param client
     * @return
     */
    @Override
    public boolean stopCharging(ModbusRtuOverTcp client) {
        client.writeCoil(AiPowerChargerCoilEnum.AGV_REPORTED_IN_POSITION.getAddr(), false);
        return true;
    public boolean stopCharging(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            return client.writeCoil(AiPowerChargeCoilEnum.AGV_REPORTED_IN_POSITION.getAddr(), false);
        } catch (Exception e) {
            log.info("写入停止充电指令报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return false;
    }

    /**
     * 在线正继电器状态(前进到位)
     *
     * @param client
     * @return
     */
    @Override
    public boolean checkForwardRelayOnline(ModbusRtuOverTcp client) {
        return client.readBoolean(AiPowerChargerCoilEnum.FORWARD_RELAY_ONLINE.getAddr(), 1);
    public boolean checkForwardRelayOnline(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            return client.readCoils(AiPowerChargeCoilEnum.FORWARD_RELAY_ONLINE.getAddr(), 1).getBit(0);
        } catch (Exception e) {
            log.info("读取在线正继电器状态报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return false;
    }

    /**
     * 离线正继电器状态(后退到位)
     *
     * @param client
     * @return
     */
    @Override
    public boolean checkBackwardRelayOffline(ModbusRtuOverTcp client) {
        return client.readBoolean(AiPowerChargerCoilEnum.BACKWARD_RELAY_OFFLINE.getAddr(), 1);
    public boolean checkBackwardRelayOffline(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            return client.readCoils(AiPowerChargeCoilEnum.BACKWARD_RELAY_OFFLINE.getAddr(), 1).getBit(0);
        } catch (Exception e) {
            log.info("读取离线正继电器状态报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return false;
    }

    /**
     * 获取充电机充电电压
     *
     * @param client
     * @return
     */
    @Override
    public double getVoltage(ModbusRtuOverTcp client) {
        return client.readInt16(AiPowerChargerRegisterEnum.CHARGE_VOLTAGE.getAddr(), 1) * AiPowerChargerRegisterEnum.CHARGE_CURRENT.getRaw();
    public double getVoltage(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
               client.connect();
            }
            return client.readMultipleRegisters(AiPowerChargeRegisterEnum.CHARGE_VOLTAGE.getAddr(), 1)[0].getValue() * AiPowerChargeRegisterEnum.CHARGE_CURRENT.getRaw();
        } catch (Exception e) {
            log.info("读取充电电压报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return 0;
    }

    /**
     * 获取充电机充电电流
     *
     * @param client
     * @return
     */
    @Override
    public double getCurrent(ModbusRtuOverTcp client) {
        return client.readInt16(AiPowerChargerRegisterEnum.CHARGE_CURRENT.getAddr(), 1) * AiPowerChargerRegisterEnum.CHARGE_CURRENT.getRaw();
    public double getCurrent(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            return client.readMultipleRegisters(AiPowerChargeRegisterEnum.CHARGE_CURRENT.getAddr(), 1)[0].getValue() * AiPowerChargeRegisterEnum.CHARGE_CURRENT.getRaw();
        } catch (Exception e) {
            log.info("读取充电电流报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return 0;
    }

    /**
     * 获取充电机充电模式
     *
     * @param client
     * @return
     */
    @Override
    public ChargerStatus getStatus(ModbusRtuOverTcp client) {
    public int getChargeMode(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
               client.connect();
            }
            return client.readMultipleRegisters(AiPowerChargeRegisterEnum.CHARGE_MODE.getAddr(), 1)[0].getValue();
        } catch (Exception e) {
            e.printStackTrace();
            log.info("读取充电模式报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return -1;
    }

    /**
     * 获取充电机编号
     *
     * @param client
     * @return
     */
    @Override
    public int getChargeId(ModbusTCPMaster client) {
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            return client.readMultipleRegisters(AiPowerChargeRegisterEnum.CHARGER_ID.getAddr(), 1)[0].getValue();
        } catch (Exception e) {
            e.printStackTrace();
            log.info("读取充电机编号报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }
        return -1;
    }

    /**
     * 获取充电机状态
     *
     * @param client
     * @return
     */
    @Override
    public ChargerStatus getStatus(ModbusTCPMaster client) {

        ChargerStatus status = new ChargerStatus();

        // ---------- 批量读取线圈（地址100~115共16个） ----------
        List<Boolean> coils = client.readCoil(100, 16);
        status.setWorking(coils.get(0));                      // 地址100
        status.setOverheat(coils.get(0));                     // 101
        status.setFault(coils.get(0));                        // 102
        status.setCvMode(coils.get(0));                       // 103
        status.setBatteryConnected(coils.get(0));              // 104
        status.setFanAbnormal(coils.get(0));                   // 105
        status.setPlateOverheat(coils.get(0));                 // 106
        status.setBrushPressed(coils.get(0));                  // 107
        status.setAgvReportedInPosition(coils.get(8));         // 108
        status.setChargerConfirmedAgvReady(coils.get(9));      // 109
        status.setForwardRelayOnline(coils.get(10));           // 110
        status.setBackwardRelayOffline(coils.get(11));         // 111
        status.setBmsChargeEnable(coils.get(12));              // 112
        status.setCommRs485Success(!coils.get(13));            // 113（注意：0=成功，1=超时）
        status.setCommCanSuccess(!coils.get(14));              // 114
        status.setCommBmsSuccess(!coils.get(15));              // 115
        BitVector coils = null;
        try {
            if (!client.isConnected()) {
                client.connect();
            }
            coils = client.readCoils(AiPowerChargeCoilEnum.WORK_STATUS.getAddr(), AiPowerChargeCoilEnum.values().length);
            for (int i = 0; i < coils.size(); i++) {
                switch (i) {
                    case 0:
                        status.setWorking(coils.getBit(i));
                        break;
                    case 1:
                        status.setOverheat(coils.getBit(i));
                        break;
                    case 2:
                        status.setFault(coils.getBit(i));
                        break;
                    case 3:
                        status.setCvMode(coils.getBit(i));
                        break;
                    case 4:
                        status.setBatteryConnected(coils.getBit(i));
                        break;
                    case 5:
                        status.setFanAbnormal(coils.getBit(i));
                        break;
                    case 6:
                        status.setPlateOverheat(coils.getBit(i));
                        break;
                    case 7:
                        status.setBrushPressed(coils.getBit(i));
                        break;
                    case 8:
                        status.setAgvReportedInPosition(coils.getBit(i));
                        break;
                    case 9:
                        status.setChargerConfirmedAgvReady(coils.getBit(i));
                        break;
                    case 10:
                        status.setForwardRelayOnline(coils.getBit(i));
                        break;
                    case 11:
                        status.setBackwardRelayOffline(coils.getBit(i));
                        break;
                    case 12:
                        status.setBmsChargeEnable(coils.getBit(i));
                        break;
                    case 13:
                        status.setCommRs485Success(!coils.getBit(i));
                        break;
                    case 14:
                        status.setCommCanSuccess(!coils.getBit(i));
                        break;
                    case 15:
                        status.setCommBmsSuccess(!coils.getBit(i));
                        break;
                    default:
                        break;
                }
            }

        // ---------- 批量读取保持寄存器（地址100~116共17个） ----------
        byte[] bytes = client.readHoldRegister(100, 16);
        status.setVoltage(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.CHARGE_VOLTAGE.getRaw());
        status.setCurrent(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.CHARGE_CURRENT.getRaw());
        status.setChargingTime(ByteUtils.getInt(bytes, 0));
        status.setCapacity(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.CHARGE_CAPACITY.getRaw());
        status.setEnergy(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.CHARGE_ENERGY.getRaw());
        status.setCellMaxVoltage(ByteUtils.getInt(bytes, 0));
        status.setCellMinVoltage(ByteUtils.getInt(bytes, 0));
        status.setPackVoltage(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.BMS_PACK_VOLTAGE.getRaw());
        status.setVoltageDemand(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.BMS_VOLTAGE_DEMAND.getRaw());
        status.setCurrentDemand(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.BMS_CURRENT_DEMAND.getRaw());
        status.setTemperature(ByteUtils.getInt(bytes, 0));
        status.setSoc(ByteUtils.getInt(bytes, 0) * AiPowerChargerRegisterEnum.BMS_SOC.getRaw());
        status.setEndFlag(ByteUtils.getInt(bytes, 0));
        status.setChargerId(ByteUtils.getInt(bytes, 0));
        status.setFaultCode(ByteUtils.getInt(bytes, 0));
        status.setChargeMode(ByteUtils.getInt(bytes, 0));
        status.setScheduleFlag(ByteUtils.getInt(bytes, 0));
            // ---------- 批量读取保持寄存器（地址100~116共17个） ----------

            Register[] registers = client.readMultipleRegisters(AiPowerChargeRegisterEnum.CHARGE_VOLTAGE.getAddr(), AiPowerChargeRegisterEnum.values().length);
            for (int i = 0; i < registers.length; i++) {
                switch (i) {
                    case 0:
                        status.setVoltage(registers[i].getValue() * AiPowerChargeRegisterEnum.CHARGE_VOLTAGE.getRaw());
                        break;
                    case 1:
                        status.setCurrent(registers[i].getValue() * AiPowerChargeRegisterEnum.CHARGE_CURRENT.getRaw());
                        break;
                    case 2:
                        status.setChargingTime(registers[i].getValue());
                        break;
                    case 3:
                        status.setCapacity(registers[i].getValue() * AiPowerChargeRegisterEnum.CHARGE_CAPACITY.getRaw());
                        break;
                    case 4:
                        status.setEnergy(registers[i].getValue() * AiPowerChargeRegisterEnum.CHARGE_ENERGY.getRaw());
                        break;
                    case 5:
                        status.setCellMaxVoltage(registers[i].getValue());
                        break;
                    case 6:
                        status.setCellMinVoltage(registers[i].getValue());
                        break;
                    case 7:
                        status.setPackVoltage(registers[i].getValue() * AiPowerChargeRegisterEnum.BMS_PACK_VOLTAGE.getRaw());
                        break;
                    case 8:
                        status.setVoltageDemand(registers[i].getValue() * AiPowerChargeRegisterEnum.BMS_VOLTAGE_DEMAND.getRaw());
                        break;
                    case 9:
                        status.setCurrentDemand(registers[i].getValue() * AiPowerChargeRegisterEnum.BMS_CURRENT_DEMAND.getRaw());
                        break;
                    case 10:
                        status.setTemperature(registers[i].getValue());
                        break;
                    case 11:
                        status.setSoc(registers[i].getValue() * AiPowerChargeRegisterEnum.BMS_SOC.getRaw());
                        break;
                    case 12:
                        status.setEndFlag(registers[i].getValue());
                        break;
                    case 13:
                        status.setChargerId(registers[i].getValue());
                        break;
                    case 14:
                        status.setFaultCode(registers[i].getValue());
                        break;
                    case 15:
                        status.setChargeMode(registers[i].getValue());
                        break;
                    case 16:
                        status.setScheduleFlag(registers[i].getValue());
                        break;
                    default:
                        break;
                }
            }
        } catch (Exception e) {
            log.info("批量读取线圈报错:{} ", e.getMessage());
            log.info("批量读取保持寄存器报错:{} ", e.getMessage());
        }finally {
            //client.disconnect();
        }

        return status;
    }


    // 清除故障
    /**
     * 清除故障
     *
     * @param client
     * @return
     */
    @Override
    public boolean clearFault(ModbusRtuOverTcp client) {
        client.writeInt16(AiPowerChargerRegisterEnum.SCHEDULE_FLAG.getAddr(), (short) 1);
    public boolean clearFault(ModbusTCPMaster client) {
        try {
            client.writeSingleRegister(AiPowerChargeRegisterEnum.SCHEDULE_FLAG.getAddr(), new SimpleRegister(1));
        } catch (ModbusException e) {
            log.error("充电器清除故障失败......");
        }
        return true;
    }

    // 完成退回命令
    /**
     * 完成退回
     *
     * @param client
     * @return
     */
    @Override
    public boolean finishRetract(ModbusRtuOverTcp client) {
        client.writeInt16(AiPowerChargerRegisterEnum.SCHEDULE_FLAG.getAddr(), (short) 2);
    public boolean finishRetract(ModbusTCPMaster client) {
        try {
            client.writeSingleRegister(AiPowerChargeRegisterEnum.SCHEDULE_FLAG.getAddr(), new SimpleRegister(2));
        } catch (ModbusException e) {
            log.error("充电器完成退回失败......");
        }
        return true;
    }

    // 恢复待机状态
    /**
     * 恢复待机
     *
     * @param client
     * @return
     */
    @Override
    public boolean restoreStandby(ModbusRtuOverTcp client) {
        client.writeInt16(AiPowerChargerRegisterEnum.SCHEDULE_FLAG.getAddr(), (short) 3);
    public boolean restoreStandby(ModbusTCPMaster client) {
        try {
            client.writeSingleRegister(AiPowerChargeRegisterEnum.SCHEDULE_FLAG.getAddr(), new SimpleRegister(3));
        } catch (ModbusException e) {
            log.error("充电器恢复待机失败......");
        }
        return true;
    }


}