更新 部分电池数据统计接口

whycxzp

2021-03-23 05d62d511d819d7752b361b63f2451d0a4f2e638

更新 部分电池数据统计接口

 src/main/java/com/whyc/controller/BatteryDataController.java

@@ -52,6 +52,9 @@
        return service.getMonRes(userId);
    }

    /**
     * TODO:单体容量统计,统计格式待定
     */
    @GetMapping("monCap")
    @ApiOperation(value = "单体容量统计")
    public Response getMonCap(@RequestParam Integer userId){

 src/main/java/com/whyc/dto/BatteryInfo.java

@@ -27,9 +27,9 @@
    private Float minTestCap;
    private Float avgTestCap;

    private Float maxTestVol;
    private Float minTestVol;
    private Float avgTestVol;
    private Float maxMonVol;
    private Float minMonVol;
    private Float avgMonVol;

    public String getStationName() {
        return stationName;
@@ -135,27 +135,27 @@
        this.avgTestCap = avgTestCap;
    }

    public Float getMaxTestVol() {
        return maxTestVol;
    public Float getMaxMonVol() {
        return maxMonVol;
    }

    public void setMaxTestVol(Float maxTestVol) {
        this.maxTestVol = maxTestVol;
    public void setMaxMonVol(Float maxMonVol) {
        this.maxMonVol = maxMonVol;
    }

    public Float getMinTestVol() {
        return minTestVol;
    public Float getMinMonVol() {
        return minMonVol;
    }

    public void setMinTestVol(Float minTestVol) {
        this.minTestVol = minTestVol;
    public void setMinMonVol(Float minMonVol) {
        this.minMonVol = minMonVol;
    }

    public Float getAvgTestVol() {
        return avgTestVol;
    public Float getAvgMonVol() {
        return avgMonVol;
    }

    public void setAvgTestVol(Float avgTestVol) {
        this.avgTestVol = avgTestVol;
    public void setAvgMonVol(Float avgMonVol) {
        this.avgMonVol = avgMonVol;
    }
}

 src/main/java/com/whyc/service/BatteryDataService.java

@@ -8,10 +8,12 @@
import com.whyc.mapper.BatteryTestDataMapper;
import com.whyc.pojo.BatteryEndurance;
import com.whyc.pojo.BatteryRTState;
import com.whyc.util.BattCapFactory;
import com.whyc.util.MathUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.DecimalFormat;
import java.util.*;

@Service
@@ -166,14 +168,90 @@
            }
            //查询标准
            List<BatteryInfo> batteryStdList = testDataMapper.getVolAndCapStd(ids);
            //查询最值
            //查询最值,电池组内每个单体的最值集合
            List<BatteryInfo> batteryStatisticList = testDataMapper.getCapStatisticsByBattGroupIds(ids);

            //统计值
            double minMonCap = 0.00;
            double maxMonCap = 0.00;
            double avgMonCap = 0.00;
            double avgMonCapSum=0.00;
            int count = 0;
            DecimalFormat decimalFormat = new DecimalFormat(".00");

            List<Double> minMonCapList =new LinkedList<>();
            List<Double> maxMonCapList =new LinkedList<>();

            for(BatteryInfo monData:batteryStatisticList){
                //求每个单体容量的最值
                //获取最小单体实际容量
                for (int i = 0; i < batteryStdList.size(); i++) {
                    if(batteryStdList.get(i).getBatteryGroupId()==monData.getBatteryGroupId()){

                        int hourRateMin = BattCapFactory.GetHourRate(batteryStdList.get(i).getMonCapStd(), monData.getMinTestCurr());
                        double monRealCapMin = BattCapFactory.GetMonomerCap(batteryStdList.get(i).getMonCapStd(), hourRateMin, monData.getMinTestCap(), monData.getMaxMonVol(), monData.getMinMonVol(), batteryStdList.get(i).getMonVolStd(), BattCapFactory.CapType_Real);
                        monRealCapMin = Double.parseDouble(decimalFormat.format(monRealCapMin));
                        minMonCapList.add(monRealCapMin);

                        //获取最大单体实际容量
                        int hourRateMax = BattCapFactory.GetHourRate(batteryStdList.get(i).getMonCapStd(), monData.getMaxTestCurr());
                        double monRealCapMax = BattCapFactory.GetMonomerCap(batteryStdList.get(i).getMonCapStd(), hourRateMax, monData.getMaxTestCap(), monData.getMaxMonVol(), monData.getMinMonVol(), batteryStdList.get(i).getMonVolStd(), BattCapFactory.CapType_Real);
                        monRealCapMax = Double.parseDouble(decimalFormat.format(monRealCapMax));
                        maxMonCapList.add(monRealCapMax);

                        //获取平均单体实际容量
                        int hourRateAvg = BattCapFactory.GetHourRate(batteryStdList.get(i).getMonCapStd(), monData.getAvgTestCurr());
                        double monRealCapAvg = BattCapFactory.GetMonomerCap(batteryStdList.get(i).getMonCapStd(), hourRateAvg, monData.getAvgTestCap(), monData.getMaxMonVol(), monData.getMinMonVol(), batteryStdList.get(i).getMonVolStd(), BattCapFactory.CapType_Real);
                        avgMonCapSum+=monRealCapAvg;
                        count++;
                    }
                }
            }
            minMonCap = min(minMonCapList);
            maxMonCap = max(maxMonCapList);
            avgMonCap = avgMonCapSum / count;
            avgMonCap=Double.parseDouble(decimalFormat.format(avgMonCap));

            //单体容量
            /*minCapList.add(minMonCap);
            maxCapList.add(maxMonCap);
            averageCapList.add(avgMonCap);*/
            
            resMap.put(temp.getStationName(),null);
        }
        return new Response<>().set(1,resMap);

    }

    public double min(List<Double> list){
        double min=0.00;
        for (int i = 0; i < list.size(); i++) {
            if(i==0){
                min=list.get(i);
            }else{
                if (list.get(i)<min){
                    min =list.get(i);
                }
            }
        }
        return min;

    }

    public double max(List<Double> list){
        double max=0.00;
        for (int i = 0; i < list.size(); i++) {
            if(i==0){
                max=list.get(i);
            }else{
                if (list.get(i)>max){
                    max =list.get(i);
                }
            }
        }
        return max;
    }


    public static void main(String[] args) {
        BatteryEndurance endurance = new BatteryEndurance();

 src/main/java/com/whyc/util/BattCapFactory.java

New file
@@ -0,0 +1,164 @@
package com.whyc.util;

import com.whyc.constant.AlarmConstant;

public class BattCapFactory {
    public static int  CapType_Rest = 0;            //当查询剩余容量时传递
    public static int  CapType_Real = 1;            //当查询实际容量时传递
	
    public static int  CapType_type=2;       //容量
    public static int  CapType_name=1;       //次低
    public static int  CapType_method=0;     //标称
    // 获取标纯电流
    public static double GetFDCurrent(double stdcap, int hourrate)
    {
        double res = 0.055;
        switch(hourrate)
        {
            case 1: res = 0.514; break;
            case 2: res = 0.306; break;
            case 3: res = 0.250; break;
            case 4: res = 0.200; break;
            case 5: res = 0.166; break;
            case 6: res = 0.146; break;
            case 7: res = 0.131; break;
            case 8: res = 0.118; break;
            case 9: res = 0.108; break;
            case 10: res = 0.100; break;
            case 20: res = 0.055; break;
            default: res = 0.055; break;
        }
	    
        return (stdcap * res);
    }
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    // 获取放电小时率        stdah：标纯容量          current:当前电流
    public static int GetHourRate(double stdah, double current)
    {
        int index = 0;
        double value[]={5.14, 3.06, 2.50, 2.00, 1.66, 1.46, 1.31, 1.18, 1.08, 1.00, 0.55, 0.40};
        double res;
        current = Math.abs(current);
        res = current/(stdah/10);
        if(res >= 5.14) return 1;
        else if(res <= 0.55) return 20;
        else
        {
            for(index=0; index<10; index++)
            {
                if((res<=value[index]) && (res>value[index+1]))
                    break;
                else continue;
            }
            if((value[index]-res) < (res-value[index+1]))
            {
                return (index+1);
            }
            else
            {
                if(index+2 > 10) return (20);
                else return (index+2);
            }
        }  
    }
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    public static double N_TO_10H(int n_H)
    {
        switch(n_H)
        {
            case  1 : return(1/0.55);
            case  2 : return(1/0.61);
            case  3 : return(1/0.75);
            case  4 : return(1/0.79);
            case  5 : return(1/0.833);
            case  6 : return(1/0.876);
            case  7 : return(1/0.917);
            case  8 : return(1/0.944);
            case  9 : return(1/0.974);
            case  10: return(1/1);
            case  20: return(1/1.1);
        }
        return 1.0;
    }
    //-------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------
    //获取剩余容量    STDAH：标称容量        HourRate：放电小时率    SumAH：测试容量        MaxMonomerVol：最大电池电压        MonomerVol：当前电池组的最低单体电压
    //MonomerVolType:电池电压类型 电池标称电压    2v,6v,12v    CapType:容量类型（定值是常量）
	
                                                         //小时率        已测试容量            最容量
    public static double GetMonomerCap(double STDAH, int HourRate, double SumAH, double MaxMonomerVol,
																
                                        double MonomerVol, double MonomerVolType, int CapType)
    {
        if((MaxMonomerVol - MonomerVolType*0.9) <= 0)
            return 0;

        if(SumAH < 0)
            SumAH *= (-1);

        double tmp_cap;
        tmp_cap = MonomerVol - MonomerVolType * 0.9;
        tmp_cap *= (STDAH - SumAH * N_TO_10H(HourRate));
        double dt_vol = MaxMonomerVol - MonomerVolType*0.9;
        if(dt_vol < 0.01)
            dt_vol = 0.01;
        tmp_cap = tmp_cap/dt_vol;
        if(tmp_cap < 0)
            tmp_cap = 0;

        if(CapType == CapType_Rest)
            return tmp_cap;
        else if(CapType == CapType_Real)
            return (tmp_cap + SumAH * N_TO_10H(HourRate));
        else
            return ((tmp_cap + SumAH * N_TO_10H(HourRate))*100 / STDAH);
    }
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    //获取后备时间
    public static int GetRestTimeSecond(double restcap, double curr)
    {
        double tmp_curr = Math.abs(curr);
        if(tmp_curr < 0.1)
            tmp_curr = 0.1;
			
        int rest_time = (int)((restcap / tmp_curr) * 3600);
        if(rest_time > (99*3600))
            rest_time = (99*3600);
			
        return rest_time;
    }
    //判断通过实际容量判断某次放电测试是否有效
    /*
     * STDAH:标存容量
     * param:容量有效参数*/
    public static  int Judge(double realCap,float param,double STDAH){
        int flag=0;
        if(Math.abs(realCap)>(param*STDAH)){
            flag=1;
        }else{
            flag=0;
        }
        return flag;
        }
    //判断通过实际容量判断某次放电测试是否有效
        /*
         * STDAH:标存容量
         * param:容量告警参数*/
    public static  int JudgeAlarm(double realCap,float param,float Cparam,double STDAH){
        int flag=0;
        if(realCap>(param*STDAH)){
            flag=1;
        }else{
            if(realCap<(Cparam*STDAH)){
                flag= AlarmConstant.Alarm_CapChange;
            }else{
                flag=AlarmConstant.Alarm_CapAlarm;
            }
			
        }
        return flag;
 }
}

 src/main/resources/mapper/BatteryTestDataMapper.xml

@@ -37,7 +37,7 @@
    </select>

    <select id="getVolAndCapStd" resultType="com.whyc.dto.BatteryInfo">
        select BattGroupId,MonVolStd,MonCapStd from db_battinf.tb_battinf where BattGroupId in
        select BattGroupId as batteryGroupId,MonVolStd,MonCapStd from db_battinf.tb_battinf where BattGroupId in
        <foreach collection="array" item="id" open="(" close=")" separator=",">
            #{id}
        </foreach>
@@ -45,7 +45,7 @@
    <select id="getCapStatisticsByBattGroupIds" resultType="com.whyc.dto.BatteryInfo">
        <foreach collection="array" item="id" separator=")union(" open="(" close=")">
            SELECT
                BattGroupId,
                BattGroupId as batteryGroupId,
                max( abs( test_curr ) ) maxTestCurr,
                min( abs( test_curr ) ) minTestCurr,
                avg( abs( test_curr ) ) avgTestCurr,

 src/main/resources/mapper/PowerInfoMapper.xml

@@ -2,21 +2,21 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.whyc.mapper.PowerInfoMapper" >

    <!--TODO:这个地方需要调整为电源信息表-->
    <select id="getStationCount" resultType="java.lang.Integer">
        select count(*)
        from (
            select StationId
            from db_battinf.tb_battinf
            where StationId in ( select distinct inf.StationId from
                    (select StationId from db_battinf.tb_battinf union select StationId from db_pwrdev_inf.tb_pwrdev_inf ) inf,
            from db_pwrdev_inf.tb_pwrdev_inf
            where StationId in
                (select distinct inf.StationId from db_pwrdev_inf.tb_pwrdev_inf inf,
                    db_user.tb_user_battgroup_baojigroup_battgroup,
                    db_user.tb_user_battgroup_baojigroup_usr,
                    db_user.tb_user_inf
                    where db_user.tb_user_battgroup_baojigroup_battgroup.StationId=inf.StationId
                    and db_user.tb_user_battgroup_baojigroup_usr.baoji_group_id=db_user.tb_user_battgroup_baojigroup_battgroup.baoji_group_id
                    and db_user.tb_user_inf.uid=db_user.tb_user_battgroup_baojigroup_usr.uid
                    and db_user.tb_user_inf.uid=#{userId})
                where db_user.tb_user_battgroup_baojigroup_battgroup.StationId=inf.StationId
                and db_user.tb_user_battgroup_baojigroup_usr.baoji_group_id=db_user.tb_user_battgroup_baojigroup_battgroup.baoji_group_id
                and db_user.tb_user_inf.uid=db_user.tb_user_battgroup_baojigroup_usr.uid
                and db_user.tb_user_inf.uid=#{userId}
            )
            group by StationId
        ) temp
    </select>