实时页面推送头部top

whyclxw

2025-05-26 a2df4b74a01e54b396dc696791f2377219915209

实时页面推送头部top

 src/main/java/com/whyc/dto/Real/TopDto.java

@@ -4,7 +4,40 @@

@Data
public class TopDto {
    private Integer systemState;
    private Integer devState;
    private Integer battState;
    private Integer systemState;  //系统状态
    private Integer devState;    //设备状态
    private Integer battState;   //电池状态
    private Integer pwrState;    //电源状态
    private Float vbusVol;      //母线电压
    private Float onlineVol;   //在线电压
    private Integer battALmNum;//电池组实时告警数
    private Integer devALmNum; //设备实时告警数
    private Integer pwrALmNum; //电源实时告警数
    private Integer allALmNum; //电源实时告警数
    //仅在设备状态为核容测试有效
    private Float captestGroupvol;     //组端电压
    private Float captestCurr;           //电池电流
    private Integer captestTimelong;    //测试时长
    private Float captestCap;           //测试容量
    private Float restCap;              //预估剩余容量
    private Integer restTime;           //预估剩余续航时间

    public TopDto() {
        this.systemState = 0;
        this.devState = 0;
        this.battState = 0;
        this.pwrState = 0;
        this.vbusVol = 0.0f;
        this.onlineVol = 0.0f;
        this.battALmNum = 0;
        this.devALmNum = 0;
        this.pwrALmNum = 0;
        this.captestGroupvol = 0.0f;
        this.captestCurr = 0.0f;
        this.captestTimelong = 0;
        this.captestCap = 0.0f;
        this.restCap = 0.0f;
        this.restTime = 0;
        this.allALmNum = 0;
    }
}

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

New file
@@ -0,0 +1,172 @@
package com.whyc.factory;

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=AlarmDaoFactory.Alarm_CapChange;
            }else{
                flag=AlarmDaoFactory.Alarm_CapAlarm;
            }
			
        }
        return flag;
     }*/

    /**
     * 电池组的续航时长计算,单位:分钟
     */
    public static float getTheoryTime(float loadCurr, float battGroupCap, float battGroupCapStd){
        double realCurr = 53*loadCurr/45;
        double hourRate = N_TO_10H(GetHourRate((int) Math.floor(battGroupCapStd), realCurr));
        float theoryTimeHour = realCurr == 0?0: (float) (battGroupCap / hourRate / realCurr);
        return theoryTimeHour*60;
    }
}

 src/main/java/com/whyc/mapper/BattRtstateMapper.java

New file
@@ -0,0 +1,6 @@
package com.whyc.mapper;

import com.whyc.pojo.db_ram_db.BattRtstate;

public interface BattRtstateMapper extends CustomMapper<BattRtstate>{
}

 src/main/java/com/whyc/mapper/BatttestdataInfMapper.java

New file
@@ -0,0 +1,6 @@
package com.whyc.mapper;

import com.whyc.pojo.db_batt_testdata.BatttestdataInf;

public interface BatttestdataInfMapper extends CustomMapper<BatttestdataInf>{
}

 src/main/java/com/whyc/mapper/DeviceStateMapper.java

New file
@@ -0,0 +1,6 @@
package com.whyc.mapper;

import com.whyc.pojo.db_ram_db.DeviceState;

public interface DeviceStateMapper extends CustomMapper<DeviceState>{
}

 src/main/java/com/whyc/mapper/PwrdevAcdcdataMapper.java

New file
@@ -0,0 +1,6 @@
package com.whyc.mapper;

import com.whyc.pojo.db_ram_db.PwrdevAcdcdata;

public interface PwrdevAcdcdataMapper extends CustomMapper<PwrdevAcdcdata>{
}

 src/main/java/com/whyc/pojo/db_ram_db/DeviceState.java

@@ -53,7 +53,7 @@
    @ApiModelProperty(value = "测试组号")
    private Integer devTestgroupnum;

    @ApiModelProperty(value = "设备测试类型")
    @ApiModelProperty(value = "设备工作类型")
    private Integer devWorkstate;

    @ApiModelProperty(value = "设备告警状态")

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

New file
@@ -0,0 +1,21 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.whyc.mapper.BattRtstateMapper;
import com.whyc.pojo.db_ram_db.BattRtstate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BattRtstateService {
    @Autowired(required = false)
    private BattRtstateMapper mapper;
    //实时获取电池组信息
    public BattRtstate getBattRealInfo(Integer battgroupId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("battgroup_id",battgroupId);
        wrapper.last("limit 1");
        BattRtstate batt=mapper.selectOne(wrapper);
        return batt;
    }
}

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

@@ -1,5 +1,6 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
@@ -36,4 +37,13 @@
        int flag=mapper.update((BattalarmData) ActionUtil.objeNull,wrapper);
        return  new Response().set(1,flag>0,flag>0?"确认成功":"确认失败");
    }
    //获取一级未处理实时告警数
    public Integer getBattAlmNum(Integer battgroupId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("battgroup_id",battgroupId);
        wrapper.eq("alm_is_confirmed",0);
        wrapper.eq("alm_level",1);
        List<BattalarmData> list=mapper.selectList(wrapper);
        return list!=null?list.size():0;
    }
}

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

New file
@@ -0,0 +1,7 @@
package com.whyc.service;

import org.springframework.stereotype.Service;

@Service
public class BatttestdataIdService {
}

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

New file
@@ -0,0 +1,34 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.whyc.factory.BattCapFactory;
import com.whyc.mapper.BattInfMapper;
import com.whyc.mapper.BatttestdataInfMapper;
import com.whyc.pojo.db_batt_testdata.BatttestdataInf;
import com.whyc.pojo.db_station.BattInf;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BatttestdataInfService {
    @Autowired(required = false)
    private BatttestdataInfMapper mapper;


    //获取最后一次测试数据并计算剩余容量
    public Float getLastTestDataRestCap(Integer battgroupId) {
        //获取放电记录
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("battgroup_id",battgroupId);
        wrapper.orderByDesc("test_starttime");
        wrapper.last("limit 1");
        BatttestdataInf tinf=mapper.selectOne(wrapper);
        if(tinf!=null){
            int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
            Float restcap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Rest);
            return restcap;
        }else{
            return 0f;
        }
    }
}

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

@@ -1,5 +1,6 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
@@ -37,4 +38,13 @@
        int flag=mapper.update((DevalarmData) ActionUtil.objeNull,wrapper);
        return  new Response().set(1,flag>0,flag>0?"确认成功":"确认失败");
    }
    //获取一级未处理实时告警数
    public Integer getDevAlmNum(Integer devId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("dev_id",devId);
        wrapper.eq("alm_is_confirmed",0);
        wrapper.eq("alm_level",1);
        List<DevalarmData> list=mapper.selectList(wrapper);
        return list!=null?list.size():0;
    }
}

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

New file
@@ -0,0 +1,22 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.whyc.mapper.DeviceStateMapper;
import com.whyc.pojo.db_ram_db.BattRtstate;
import com.whyc.pojo.db_ram_db.DeviceState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DeviceStateService {
    @Autowired(required = false)
    private DeviceStateMapper mapper;
    //实时获取设备信息
    public DeviceState getDevRealInfo(Integer devId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("dev_id",devId);
        wrapper.last("limit 1");
        DeviceState dev=mapper.selectOne(wrapper);
        return dev;
    }
}

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

New file
@@ -0,0 +1,22 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.whyc.mapper.PwrdevAcdcdataMapper;
import com.whyc.pojo.db_ram_db.BattRtstate;
import com.whyc.pojo.db_ram_db.PwrdevAcdcdata;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class PwrdevAcdcdataService {
    @Autowired(required = false)
    private PwrdevAcdcdataMapper mapper;
    //实时获取电源信息
    public PwrdevAcdcdata getPwrRealInfo(Integer powerId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("power_id",powerId);
        wrapper.last("limit 1");
        PwrdevAcdcdata pwr=mapper.selectOne(wrapper);
        return pwr;
    }
}

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

@@ -1,5 +1,6 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
@@ -37,4 +38,13 @@
        int flag=mapper.update((PwrdevAlarm) ActionUtil.objeNull,wrapper);
        return  new Response().set(1,flag>0,flag>0?"确认成功":"确认失败");
    }
    //获取一级未处理实时告警数
    public Integer getPwrAlmNum(Integer powerId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("power_id",powerId);
        wrapper.eq("alm_is_confirmed",0);
        wrapper.eq("alm_level",1);
        List<DevalarmData> list=mapper.selectList(wrapper);
        return list!=null?list.size():0;
    }
}

 src/main/java/com/whyc/webSocket/RealTimeSocket.java

@@ -1,9 +1,15 @@
package com.whyc.webSocket;

import com.whyc.config.WebSocketConfig;
import com.whyc.dto.Real.TopDto;
import com.whyc.dto.RealTimeDto;
import com.whyc.dto.Response;
import com.whyc.factory.BattCapFactory;
import com.whyc.pojo.db_ram_db.BattRtstate;
import com.whyc.pojo.db_ram_db.DeviceState;
import com.whyc.pojo.db_ram_db.PwrdevAcdcdata;
import com.whyc.pojo.db_user.User;
import com.whyc.service.*;
import com.whyc.util.ActionUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -20,8 +26,23 @@
    private Session session;

    private Thread thread;
    //实时数据
    private static BattRtstateService battRtstateService;

    //private static LockAlarmService almService;
    private static DeviceStateService  deviceStateService;

    private static PwrdevAcdcdataService  pwrdevAcdcdataService;

    //实时告警
    private static BattalarmDataService  battalarmDataService;

    private static DevalarmDataService devalarmDataService;

    private static PwrdevAlarmService  pwrdevAlarmService;

    //放电记录
    private static BatttestdataInfService batttestdataInfService;



    private volatile boolean runFlag = true;
@@ -32,10 +53,41 @@

    private volatile Map<Long,Boolean> threadFlagMap = new HashMap<>();

    /*@Autowired
    public void setLockAlarmService(LockAlarmService almService) {
        LockAlmRtSocket.almService = almService;
    }*/
    @Autowired
    public void setBattRtstateService(BattRtstateService battRtstateService) {
        RealTimeSocket.battRtstateService = battRtstateService;
    }

    @Autowired
    public void setDeviceStateService(DeviceStateService deviceStateService) {
        RealTimeSocket.deviceStateService = deviceStateService;
    }

    @Autowired
    public void setPwrdevAcdcdataService(PwrdevAcdcdataService pwrdevAcdcdataService) {
        RealTimeSocket.pwrdevAcdcdataService = pwrdevAcdcdataService;
    }

    @Autowired
    public void setBattalarmDataService(BattalarmDataService battalarmDataService) {
        RealTimeSocket.battalarmDataService = battalarmDataService;
    }

    @Autowired
    public void setDevalarmDataService(DevalarmDataService devalarmDataService) {
        RealTimeSocket.devalarmDataService = devalarmDataService;
    }

    @Autowired
    public void setPwrdevAlarmService(PwrdevAlarmService pwrdevAlarmService) {
        RealTimeSocket.pwrdevAlarmService = pwrdevAlarmService;
    }

    @Autowired
    public void setBatttestdataInfService(BatttestdataInfService batttestdataInfService) {
        RealTimeSocket.batttestdataInfService = batttestdataInfService;
    }



    @OnOpen
@@ -69,7 +121,7 @@
                        if (session.isOpen()) {
                            //推送信息
                            synchronized (session) {
                                session.getBasicRemote().sendObject(new Response<>().set(1,map));
                                session.getBasicRemote().sendObject(new Response<>().setII(1,true,map,"实时页面数据推送"));
                            }
                            threadFlagMap.put(thread.getId(), false);
                        }
@@ -94,7 +146,53 @@
    }
    //获取头部信息
    private Response getTop(RealTimeDto realDto) {
        return new Response().set(1);
        TopDto topDto = new TopDto();
        try {
            //实时获取电池组信息
            BattRtstate battRtstate = battRtstateService.getBattRealInfo(realDto.getBattgroupId());
            if (battRtstate != null) {
                topDto.setBattState(battRtstate.getBattState());
                topDto.setVbusVol(battRtstate.getVbusVol());
                topDto.setOnlineVol(battRtstate.getOnlineVol());
            }
            //实时获取设备信息
            DeviceState deviceState = deviceStateService.getDevRealInfo(realDto.getDevId());
            if (deviceState != null) {
                topDto.setDevState(deviceState.getDevWorkstate());
                if (deviceState.getDevWorkstate() == 1) {//核容放电
                    topDto.setCaptestGroupvol(deviceState.getDevCaptestGroupvol());
                    topDto.setCaptestCurr(deviceState.getDevCaptestCurr());
                    topDto.setCaptestTimelong(deviceState.getDevCaptestTimelong());
                    topDto.setCaptestCap(deviceState.getDevCaptestCap());
                    //剩余容量和剩余时间计算
                    Float restCap = batttestdataInfService.getLastTestDataRestCap(realDto.getBattgroupId());
                    topDto.setRestCap(restCap);
                    /*Integer restTime= BattCapFactory.getTheoryTime(deviceState.getDevCaptestCurr(), battRtstate.getBattGroupCap(), battRtstate.getBattGroupCapStd());
                    topDto.setRestTime(restTime);*/
                }
                //实时获取电源信息
                PwrdevAcdcdata pwrdevAcdcdata = pwrdevAcdcdataService.getPwrRealInfo(realDto.getPowerId());
                if (pwrdevAcdcdata != null) {
                    //topDto.setPwrState(pwrdevAcdcdata.getPwrState());
                }
                //获取一级未处理实时告警数
                Integer battALmNum = battalarmDataService.getBattAlmNum(realDto.getBattgroupId());
                topDto.setBattALmNum(battALmNum);

                Integer devALmNum = devalarmDataService.getDevAlmNum(realDto.getDevId());
                topDto.setDevALmNum(devALmNum);

                Integer pwrALmNum = pwrdevAlarmService.getPwrAlmNum(realDto.getPowerId());
                topDto.setPwrALmNum(pwrALmNum);

                Integer allALmNum = battALmNum + devALmNum + pwrALmNum;
                topDto.setAllALmNum(allALmNum);
                topDto.setSystemState((allALmNum > 0 ? 1 : 0));
            }
            return new Response().setII(1, true, topDto, "实时页面头部数据推送");
        } catch (Exception e) {
            return new Response().set(1, false, "实时页面头部数据推送");
        }
    }

    //根据pageType获取返回界面