diff --git a/fastbee-iot-data/src/main/java/com/fastbee/iot/data/service/impl/DeviceJobServiceImpl.java b/fastbee-iot-data/src/main/java/com/fastbee/iot/data/service/impl/DeviceJobServiceImpl.java
index b5123ff1..11fb35a9 100644
--- a/fastbee-iot-data/src/main/java/com/fastbee/iot/data/service/impl/DeviceJobServiceImpl.java
+++ b/fastbee-iot-data/src/main/java/com/fastbee/iot/data/service/impl/DeviceJobServiceImpl.java
@@ -44,7 +44,7 @@ public class DeviceJobServiceImpl implements IDeviceJobService {
     /**
      * 项目启动时，初始化定时器 主要是防止手动修改数据库导致未同步到定时任务处理（注：不能手动修改数据库ID和任务组名，否则会导致脏数据）
      */
-    @PostConstruct
+    //@PostConstruct
     public void init() throws SchedulerException, TaskException {
         scheduler.clear();
         // 设备定时任务
diff --git a/fastbee-open-api/src/main/java/com/fastbee/controller/datacenter/DataCenterController.java b/fastbee-open-api/src/main/java/com/fastbee/controller/datacenter/DataCenterController.java
index 74da13dc..997debdf 100644
--- a/fastbee-open-api/src/main/java/com/fastbee/controller/datacenter/DataCenterController.java
+++ b/fastbee-open-api/src/main/java/com/fastbee/controller/datacenter/DataCenterController.java
@@ -9,7 +9,10 @@ import com.fastbee.common.utils.DateUtils;
 import com.fastbee.common.utils.StringUtils;
 import com.fastbee.iot.domain.ThingsModel;
 import com.fastbee.iot.model.AlertCountVO;
+import com.fastbee.iot.model.DataQualityVO;
 import com.fastbee.iot.model.DeviceHistoryParam;
+import com.fastbee.iot.model.DeviceStatsVO;
+import com.fastbee.iot.model.HistogramVO;
 import com.fastbee.iot.model.SubDeviceCompareParam;
 import com.fastbee.iot.model.ThingsModelLogCountVO;
 import com.fastbee.iot.model.dto.ThingsModelDTO;
@@ -68,6 +71,48 @@ public class DataCenterController {
         return AjaxResult.success(jsonObject);
     }
 
+    @ApiOperation("查询设备物模型统计指标（最大/最小/均值/累计/数据量/最新值），支持网关设备")
+    @PreAuthorize("@ss.hasPermi('dataCenter:analysis:list')")
+    @PostMapping("/deviceStats")
+    public AjaxResult deviceStats(@RequestBody DeviceHistoryParam deviceHistoryParam) {
+        if (deviceHistoryParam.getDeviceId() == null) {
+            return AjaxResult.error("请选择设备");
+        }
+        if (StringUtils.isNotEmpty(deviceHistoryParam.getSerialNumber())) {
+            deviceHistoryParam.setSerialNumber(deviceHistoryParam.getSerialNumber().toUpperCase());
+        }
+        List<DeviceStatsVO> list = dataCenterService.deviceStats(deviceHistoryParam);
+        return AjaxResult.success(list);
+    }
+
+    @ApiOperation("数据质量分析：上报间隔估算、缺数时间段、连续重复值检测、质量评分、7×24热力图")
+    @PreAuthorize("@ss.hasPermi('dataCenter:analysis:list')")
+    @PostMapping("/deviceDataQuality")
+    public AjaxResult deviceDataQuality(@RequestBody DeviceHistoryParam deviceHistoryParam) {
+        if (deviceHistoryParam.getDeviceId() == null) {
+            return AjaxResult.error("请选择设备");
+        }
+        if (StringUtils.isNotEmpty(deviceHistoryParam.getSerialNumber())) {
+            deviceHistoryParam.setSerialNumber(deviceHistoryParam.getSerialNumber().toUpperCase());
+        }
+        List<DataQualityVO> list = dataCenterService.deviceDataQuality(deviceHistoryParam);
+        return AjaxResult.success(list);
+    }
+
+    @ApiOperation("值分布直方图：统计每个物模型标识符在查询时段内的值区间分布频次")
+    @PreAuthorize("@ss.hasPermi('dataCenter:analysis:list')")
+    @PostMapping("/deviceHistogram")
+    public AjaxResult deviceHistogram(@RequestBody DeviceHistoryParam deviceHistoryParam) {
+        if (deviceHistoryParam.getDeviceId() == null) {
+            return AjaxResult.error("请选择设备");
+        }
+        if (StringUtils.isNotEmpty(deviceHistoryParam.getSerialNumber())) {
+            deviceHistoryParam.setSerialNumber(deviceHistoryParam.getSerialNumber().toUpperCase());
+        }
+        List<HistogramVO> list = dataCenterService.deviceHistogram(deviceHistoryParam);
+        return AjaxResult.success(list);
+    }
+
     @ApiOperation("网关产品-可导入的子产品物模型列表（按identifier去重）")
     @PreAuthorize("@ss.hasPermi('iot:model:list')")
     @GetMapping("/subProductThingsModel")
diff --git a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/domain/DeviceDeferredCommand.java b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/domain/DeviceDeferredCommand.java
index 69676e7b..c63dec40 100644
--- a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/domain/DeviceDeferredCommand.java
+++ b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/domain/DeviceDeferredCommand.java
@@ -22,22 +22,66 @@ public class DeviceDeferredCommand {
     // 执行失败
     public static final int STATUS_FAILED = 3;
 
+    /**
+     * 主键
+     */
     private Long id;
+
+    /**
+     * 设备序列号
+     */
     private String serialNumber;
+
+    /**
+     * 主题名称
+     */
     private String topicName;
+
+    /**
+     * 消息体hex
+     */
     private String messageHex;
+
+    /**
+     * 数据类型
+     */
     private String dataType;
+
+    /**
+     * 任务类型
+     */
     private Integer taskType;
+
+    /**
+     * 状态（0：待执行，1：执行中，2：执行成功，3：执行失败）
+     */
     private Integer status;
+
+    /**
+     * 消息体hash值
+     */
     private String payloadHash;
+
+    /**
+     * 错误信息
+     */
     private String errMsg;
 
+    /**
+     * 创建时间
+     */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date createTime;
 
+    /**
+     * 过期时间
+     */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date expireTime;
 
+    /**
+     * 调度时间
+     */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date dispatchTime;
 }
diff --git a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/DataQualityVO.java b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/DataQualityVO.java
new file mode 100644
index 00000000..234769d4
--- /dev/null
+++ b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/DataQualityVO.java
@@ -0,0 +1,62 @@
+package com.fastbee.iot.model;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 设备物模型数据质量 VO
+ * 包含：上报间隔估算、缺数时间段列表、重复值统计
+ */
+@Data
+public class DataQualityVO {
+
+    /** 标识符 */
+    private String identifier;
+
+    /** 物模型名称 */
+    private String modelName;
+
+    /** 所属设备序列号 */
+    private String serialNumber;
+
+    /** 时间范围内实际数据量 */
+    private Long totalCount;
+
+    /** 估算平均上报间隔（秒） */
+    private Long avgIntervalSeconds;
+
+    /** 缺数时间段列表（间隔超过 5× 平均间隔视为缺数） */
+    private List<MissingSegment> missingSegments;
+
+    /** 缺数段数量 */
+    private Integer missingCount;
+
+    /** 缺数总时长（分钟） */
+    private Long totalMissingMinutes;
+
+    /** 连续重复值数量 */
+    private Long repeatCount;
+
+    /** 连续重复率（0~100） */
+    private Double repeatRate;
+
+    /** 数据质量评分（0~100，综合缺数率和重复率计算） */
+    private Integer qualityScore;
+
+    /**
+     * 7×24 上报热力图数据，每项为 [星期几(0=周日~6=周六), 小时(0~23), 数据量]
+     * 用于 ECharts heatmap 的 data 字段
+     */
+    private List<List<Integer>> heatmapData;
+
+    @Data
+    public static class MissingSegment {
+        /** 缺数段开始时间（上一条记录时间） */
+        private String gapStart;
+        /** 缺数段结束时间（下一条记录时间） */
+        private String gapEnd;
+        /** 缺数时长（分钟） */
+        private Long durationMinutes;
+    }
+}
diff --git a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/DeviceStatsVO.java b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/DeviceStatsVO.java
new file mode 100644
index 00000000..3cf3a9b9
--- /dev/null
+++ b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/DeviceStatsVO.java
@@ -0,0 +1,41 @@
+package com.fastbee.iot.model;
+
+import lombok.Data;
+
+/**
+ * 设备物模型统计指标 VO
+ * 包含查询时间范围内某一标识符的最大/最小/均值/累计值/数据量/最新值
+ */
+@Data
+public class DeviceStatsVO {
+
+    /** 标识符 */
+    private String identifier;
+
+    /** 物模型名称 */
+    private String modelName;
+
+    /** 所属设备序列号（网关子设备与网关本身 SN 不同） */
+    private String serialNumber;
+
+    /** 最大值（仅数值型属性有效） */
+    private String maxValue;
+
+    /** 最小值（仅数值型属性有效） */
+    private String minValue;
+
+    /** 平均值（仅数值型属性有效） */
+    private String avgValue;
+
+    /** 累计值（仅数值型属性有效） */
+    private String sumValue;
+
+    /** 数据量（时间范围内上报次数） */
+    private Long dataCount;
+
+    /** 最新值（时间范围内最后一条记录的值） */
+    private String lastValue;
+
+    /** 最新值对应的时间 */
+    private String lastTime;
+}
diff --git a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/HistogramVO.java b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/HistogramVO.java
new file mode 100644
index 00000000..ac1a1525
--- /dev/null
+++ b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/model/HistogramVO.java
@@ -0,0 +1,42 @@
+package com.fastbee.iot.model;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 设备物模型值分布直方图 VO
+ */
+@Data
+public class HistogramVO {
+
+    /** 标识符 */
+    private String identifier;
+
+    /** 物模型名称 */
+    private String modelName;
+
+    /** 所属设备序列号 */
+    private String serialNumber;
+
+    /** 分桶列表 */
+    private List<Bucket> buckets;
+
+    /** 非数值条数（布尔/枚举/字符串类型） */
+    private Long nonNumericCount;
+
+    /** 非数值枚举分布（key=值, value=次数），用于布尔/枚举类型 */
+    private java.util.Map<String, Long> enumDistribution;
+
+    @Data
+    public static class Bucket {
+        /** 区间标签，如 "18.00 ~ 20.00" */
+        private String label;
+        /** 区间下界（含） */
+        private Double rangeMin;
+        /** 区间上界（不含，最后一个桶含） */
+        private Double rangeMax;
+        /** 落在该区间的数据量 */
+        private Long count;
+    }
+}
diff --git a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/DataCenterService.java b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/DataCenterService.java
index b0bea964..cfa8636a 100644
--- a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/DataCenterService.java
+++ b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/DataCenterService.java
@@ -3,7 +3,10 @@ package com.fastbee.iot.service;
 import com.alibaba.fastjson2.JSONObject;
 import com.fastbee.iot.domain.ThingsModel;
 import com.fastbee.iot.model.AlertCountVO;
+import com.fastbee.iot.model.DataQualityVO;
 import com.fastbee.iot.model.DeviceHistoryParam;
+import com.fastbee.iot.model.DeviceStatsVO;
+import com.fastbee.iot.model.HistogramVO;
 import com.fastbee.iot.model.SubDeviceCompareParam;
 import com.fastbee.iot.model.dto.ThingsModelDTO;
 import com.fastbee.iot.model.ThingsModelLogCountVO;
@@ -100,4 +103,31 @@ public interface DataCenterService {
      * @return 仅计算物模型的 DTO 列表
      */
     List<ThingsModelDTO> listGatewayCalculatedModels(Long gwDeviceId);
+
+    /**
+     * 查询设备物模型在时间范围内的统计指标（最大/最小/均值/累计/数据量/最新值）
+     * 支持网关设备（自动按子设备 SN 分组查询）
+     *
+     * @param param deviceId、serialNumber、identifierList（可选）、beginTime、endTime
+     * @return 每个标识符对应的统计指标列表
+     */
+    List<DeviceStatsVO> deviceStats(DeviceHistoryParam param);
+
+    /**
+     * 数据质量分析：上报间隔估算、缺数时间段、连续重复值检测、质量评分
+     * 支持网关设备（自动按子设备 SN 分组查询）
+     *
+     * @param param deviceId、serialNumber、identifierList（可选）、beginTime、endTime
+     * @return 每个标识符对应的数据质量报告
+     */
+    List<DataQualityVO> deviceDataQuality(DeviceHistoryParam param);
+
+    /**
+     * 值分布直方图：按标识符统计值在各区间的频次分布
+     * 支持网关设备（自动按子设备 SN 分组查询）
+     *
+     * @param param deviceId、serialNumber、identifierList（可选）、beginTime、endTime
+     * @return 每个标识符对应的直方图数据
+     */
+    List<HistogramVO> deviceHistogram(DeviceHistoryParam param);
 }
diff --git a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/impl/DataCenterServiceImpl.java b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/impl/DataCenterServiceImpl.java
index dcbcae60..e2496f72 100644
--- a/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/impl/DataCenterServiceImpl.java
+++ b/fastbee-service/fastbee-iot-service/src/main/java/com/fastbee/iot/service/impl/DataCenterServiceImpl.java
@@ -14,6 +14,10 @@ import com.fastbee.iot.model.gateWay.SubDeviceListVO;
 import com.fastbee.iot.model.param.DataCenterParam;
 import com.fastbee.iot.model.scenemodel.SceneHistoryParam;
 import com.fastbee.iot.service.*;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Calendar;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.stereotype.Service;
@@ -59,60 +63,82 @@ public class DataCenterServiceImpl implements DataCenterService {
 
     @Override
     public List<JSONObject> deviceHistory(DeviceHistoryParam deviceHistoryParam) {
-        List<JSONObject> resultList = new ArrayList<>();
-        List<DeviceHistoryParam.IdentifierVO> identifierVOList = new ArrayList<>();
+        // snToIdentifiers: 每个 serialNumber 对应该 SN 下需要查询的标识符列表
+        // 对于普通设备只有一个 SN；对于网关设备，自身与各子设备 SN 不同，需分别查询
+        Map<String, List<DeviceHistoryParam.IdentifierVO>> snToIdentifiers = new LinkedHashMap<>();
+        List<String> allIdentifiers = new ArrayList<>();
+
         if (CollectionUtils.isEmpty(deviceHistoryParam.getIdentifierList())) {
+            // 未指定标识符时，从 listThingsModel 获取（已携带每个物模型真实的 serialNumber）
             List<ThingsModelDTO> list = deviceService.listThingsModel(deviceHistoryParam.getDeviceId());
-            for (ThingsModelDTO thingsModelDTO : list) {
-                DeviceHistoryParam.IdentifierVO identifierVO = new DeviceHistoryParam.IdentifierVO();
-                identifierVO.setIdentifier(thingsModelDTO.getIdentifier());
-                identifierVO.setType(thingsModelDTO.getType());
-                identifierVOList.add(identifierVO);
+            for (ThingsModelDTO dto : list) {
+                DeviceHistoryParam.IdentifierVO vo = new DeviceHistoryParam.IdentifierVO();
+                vo.setIdentifier(dto.getIdentifier());
+                vo.setType(dto.getType());
+                String sn = StringUtils.isNotEmpty(dto.getSerialNumber())
+                        ? dto.getSerialNumber()
+                        : deviceHistoryParam.getSerialNumber();
+                snToIdentifiers.computeIfAbsent(sn, k -> new ArrayList<>()).add(vo);
+                if (!allIdentifiers.contains(dto.getIdentifier())) {
+                    allIdentifiers.add(dto.getIdentifier());
+                }
             }
         } else {
-            identifierVOList = deviceHistoryParam.getIdentifierList();
+            // 显式传入标识符列表时统一使用请求中的 serialNumber
+            snToIdentifiers.put(deviceHistoryParam.getSerialNumber(), deviceHistoryParam.getIdentifierList());
+            deviceHistoryParam.getIdentifierList()
+                    .forEach(vo -> allIdentifiers.add(vo.getIdentifier()));
         }
-        if (CollectionUtils.isEmpty(identifierVOList)) {
-            return resultList;
+
+        if (snToIdentifiers.isEmpty()) {
+            return new ArrayList<>();
         }
-        List<String> identifierList = identifierVOList.stream().map(DeviceHistoryParam.IdentifierVO::getIdentifier)
-                .collect(Collectors.toList());
+
         List<HistoryModel> historyModelList = new ArrayList<>();
-        List<String> propertyIdentifierList = identifierVOList.stream().filter(t -> 1 == t.getType())
-                .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
-        if (CollectionUtils.isNotEmpty(propertyIdentifierList)) {
-            DeviceLog deviceLog = new DeviceLog();
-            deviceLog.setIdentityList(propertyIdentifierList);
-            deviceLog.setSerialNumber(deviceHistoryParam.getSerialNumber());
-            deviceLog.setBeginTime(deviceHistoryParam.getBeginTime());
-            deviceLog.setEndTime(deviceHistoryParam.getEndTime());
-            historyModelList.addAll(deviceLogService.listHistory(deviceLog));
-        }
-        List<String> functionIdentifierList = identifierVOList.stream().filter(t -> 2 == t.getType())
-                .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
-        if (CollectionUtils.isNotEmpty(functionIdentifierList)) {
-            FunctionLog functionLog = new FunctionLog();
-            functionLog.setIdentifyList(functionIdentifierList);
-            functionLog.setSerialNumber(deviceHistoryParam.getSerialNumber());
-            functionLog
-                    .setBeginTime(DateUtils.dateTime(DateUtils.YY_MM_DD_HH_MM_SS, deviceHistoryParam.getBeginTime()));
-            functionLog.setEndTime(DateUtils.dateTime(DateUtils.YY_MM_DD_HH_MM_SS, deviceHistoryParam.getEndTime()));
-            historyModelList.addAll(functionLogService.listHistory(functionLog));
-        }
-        List<String> eventIdentifierList = identifierVOList.stream().filter(t -> 3 == t.getType())
-                .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
-        if (CollectionUtils.isNotEmpty(eventIdentifierList)) {
-            EventLog eventLog = new EventLog();
-            eventLog.setIdentityList(eventIdentifierList);
-            eventLog.setSerialNumber(deviceHistoryParam.getSerialNumber());
-            Map<String, Object> params = new HashMap<>(2);
-            params.put("beginTime", deviceHistoryParam.getBeginTime());
-            params.put("endTime", deviceHistoryParam.getEndTime());
-            eventLog.setParams(params);
-            historyModelList.addAll(eventLogService.listHistory(eventLog));
+        for (Map.Entry<String, List<DeviceHistoryParam.IdentifierVO>> entry : snToIdentifiers.entrySet()) {
+            String sn = entry.getKey();
+            List<DeviceHistoryParam.IdentifierVO> identifierVOList = entry.getValue();
+
+            List<String> propertyIdentifierList = identifierVOList.stream().filter(t -> 1 == t.getType())
+                    .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(propertyIdentifierList)) {
+                DeviceLog deviceLog = new DeviceLog();
+                deviceLog.setIdentityList(propertyIdentifierList);
+                deviceLog.setSerialNumber(sn);
+                deviceLog.setBeginTime(deviceHistoryParam.getBeginTime());
+                deviceLog.setEndTime(deviceHistoryParam.getEndTime());
+                historyModelList.addAll(deviceLogService.listHistory(deviceLog));
+            }
+
+            List<String> functionIdentifierList = identifierVOList.stream().filter(t -> 2 == t.getType())
+                    .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(functionIdentifierList)) {
+                FunctionLog functionLog = new FunctionLog();
+                functionLog.setIdentifyList(functionIdentifierList);
+                functionLog.setSerialNumber(sn);
+                functionLog.setBeginTime(
+                        DateUtils.dateTime(DateUtils.YY_MM_DD_HH_MM_SS, deviceHistoryParam.getBeginTime()));
+                functionLog.setEndTime(
+                        DateUtils.dateTime(DateUtils.YY_MM_DD_HH_MM_SS, deviceHistoryParam.getEndTime()));
+                historyModelList.addAll(functionLogService.listHistory(functionLog));
+            }
+
+            List<String> eventIdentifierList = identifierVOList.stream().filter(t -> 3 == t.getType())
+                    .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(eventIdentifierList)) {
+                EventLog eventLog = new EventLog();
+                eventLog.setIdentityList(eventIdentifierList);
+                eventLog.setSerialNumber(sn);
+                Map<String, Object> params = new HashMap<>(2);
+                params.put("beginTime", deviceHistoryParam.getBeginTime());
+                params.put("endTime", deviceHistoryParam.getEndTime());
+                eventLog.setParams(params);
+                historyModelList.addAll(eventLogService.listHistory(eventLog));
+            }
         }
+
         historyModelList.sort(Comparator.comparing(HistoryModel::getTime));
-        return this.handleData(identifierList, historyModelList);
+        return this.handleData(allIdentifiers, historyModelList);
     }
 
     private List<JSONObject> handleData(List<String> identifierList, List<HistoryModel> historyModelList) {
@@ -510,10 +536,353 @@ public class DataCenterServiceImpl implements DataCenterService {
         return result;
     }
 
+    @Override
+    public List<DataQualityVO> deviceDataQuality(DeviceHistoryParam param) {
+        Map<String, List<DeviceHistoryParam.IdentifierVO>> snToIdentifiers = new LinkedHashMap<>();
+        Map<String, String> identifierToModelName = new LinkedHashMap<>();
+        Map<String, String> identifierToSn = new LinkedHashMap<>();
+        buildSnGrouping(param, snToIdentifiers, identifierToModelName, identifierToSn);
+        if (snToIdentifiers.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        // 按 identifier 聚合原始历史（仅属性类型）
+        Map<String, List<HistoryModel>> rawByIdentifier = fetchRawByIdentifier(param, snToIdentifiers, true, false);
+
+        List<DataQualityVO> result = new ArrayList<>();
+        for (Map.Entry<String, String> entry : identifierToSn.entrySet()) {
+            String identifier = entry.getKey();
+            List<HistoryModel> hList = rawByIdentifier.getOrDefault(identifier, new ArrayList<>());
+            // 按时间升序排列
+            hList.sort(Comparator.comparing(HistoryModel::getTime, Comparator.nullsLast(Comparator.naturalOrder())));
+
+            DataQualityVO vo = new DataQualityVO();
+            vo.setIdentifier(identifier);
+            vo.setModelName(identifierToModelName.getOrDefault(identifier, identifier));
+            vo.setSerialNumber(entry.getValue());
+            vo.setTotalCount((long) hList.size());
+
+            if (hList.size() >= 2) {
+                // 计算所有相邻记录的时间差（秒）
+                List<Long> gaps = new ArrayList<>();
+                for (int i = 1; i < hList.size(); i++) {
+                    Date t1 = hList.get(i - 1).getTime();
+                    Date t2 = hList.get(i).getTime();
+                    if (t1 != null && t2 != null) {
+                        gaps.add((t2.getTime() - t1.getTime()) / 1000L);
+                    }
+                }
+                if (!gaps.isEmpty()) {
+                    // 平均上报间隔（秒）
+                    long avgGap = (long) gaps.stream().mapToLong(Long::longValue).average().orElse(0);
+                    vo.setAvgIntervalSeconds(avgGap);
+
+                    // 缺数检测阈值：最大取平均间隔的5倍或5分钟，最小不超过1小时
+                    long threshold = Math.max(avgGap * 5, 300L);
+                    threshold = Math.min(threshold, 3600L);
+
+                    List<DataQualityVO.MissingSegment> segments = new ArrayList<>();
+                    long totalMissingSeconds = 0;
+                    for (int i = 0; i < gaps.size(); i++) {
+                        if (gaps.get(i) > threshold) {
+                            DataQualityVO.MissingSegment seg = new DataQualityVO.MissingSegment();
+                            seg.setGapStart(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, hList.get(i).getTime()));
+                            seg.setGapEnd(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, hList.get(i + 1).getTime()));
+                            seg.setDurationMinutes(gaps.get(i) / 60);
+                            segments.add(seg);
+                            totalMissingSeconds += gaps.get(i);
+                        }
+                    }
+                    vo.setMissingSegments(segments);
+                    vo.setMissingCount(segments.size());
+                    vo.setTotalMissingMinutes(totalMissingSeconds / 60);
+                }
+            } else {
+                vo.setMissingSegments(new ArrayList<>());
+                vo.setMissingCount(0);
+                vo.setTotalMissingMinutes(0L);
+            }
+
+            // 连续重复值检测
+            long repeatCount = 0;
+            for (int i = 1; i < hList.size(); i++) {
+                String prev = hList.get(i - 1).getValue();
+                String curr = hList.get(i).getValue();
+                if (prev != null && prev.equals(curr)) {
+                    repeatCount++;
+                }
+            }
+            vo.setRepeatCount(repeatCount);
+            if (hList.size() > 1) {
+                vo.setRepeatRate(Math.round(repeatCount * 10000.0 / (hList.size() - 1)) / 100.0);
+            } else {
+                vo.setRepeatRate(0.0);
+            }
+
+            // 质量评分（0~100）：缺数越多扣分，重复率越高扣分
+            int score = 100;
+            if (vo.getMissingCount() != null && vo.getMissingCount() > 0) {
+                // 每段缺数扣5分，最多扣50分
+                score -= Math.min(vo.getMissingCount() * 5, 50);
+            }
+            if (vo.getRepeatRate() != null && vo.getRepeatRate() > 5) {
+                score -= (int) Math.min((vo.getRepeatRate() - 5) / 2, 30);
+            }
+            vo.setQualityScore(Math.max(score, 0));
+
+            // 7×24 热力图：[dayOfWeek(0-6), hour(0-23), count]
+            int[][] heatmap = new int[7][24];
+            Calendar cal = Calendar.getInstance();
+            for (HistoryModel h : hList) {
+                if (h.getTime() != null) {
+                    cal.setTime(h.getTime());
+                    int dow = cal.get(Calendar.DAY_OF_WEEK) - 1; // 0=周日
+                    int hour = cal.get(Calendar.HOUR_OF_DAY);
+                    heatmap[dow][hour]++;
+                }
+            }
+            List<List<Integer>> heatmapData = new ArrayList<>();
+            for (int d = 0; d < 7; d++) {
+                for (int h = 0; h < 24; h++) {
+                    if (heatmap[d][h] > 0) {
+                        List<Integer> point = new ArrayList<>();
+                        point.add(h);   // ECharts x = 小时
+                        point.add(d);   // ECharts y = 星期
+                        point.add(heatmap[d][h]);
+                        heatmapData.add(point);
+                    }
+                }
+            }
+            vo.setHeatmapData(heatmapData);
+            result.add(vo);
+        }
+        return result;
+    }
+
+    @Override
+    public List<HistogramVO> deviceHistogram(DeviceHistoryParam param) {
+        Map<String, List<DeviceHistoryParam.IdentifierVO>> snToIdentifiers = new LinkedHashMap<>();
+        Map<String, String> identifierToModelName = new LinkedHashMap<>();
+        Map<String, String> identifierToSn = new LinkedHashMap<>();
+        buildSnGrouping(param, snToIdentifiers, identifierToModelName, identifierToSn);
+        if (snToIdentifiers.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        Map<String, List<HistoryModel>> rawByIdentifier = fetchRawByIdentifier(param, snToIdentifiers, true, false);
+
+        List<HistogramVO> result = new ArrayList<>();
+        for (Map.Entry<String, String> entry : identifierToSn.entrySet()) {
+            String identifier = entry.getKey();
+            List<HistoryModel> hList = rawByIdentifier.getOrDefault(identifier, new ArrayList<>());
+
+            HistogramVO vo = new HistogramVO();
+            vo.setIdentifier(identifier);
+            vo.setModelName(identifierToModelName.getOrDefault(identifier, identifier));
+            vo.setSerialNumber(entry.getValue());
+
+            // 尝试数值解析
+            List<Double> numericValues = new ArrayList<>();
+            Map<String, Long> enumDist = new LinkedHashMap<>();
+            long nonNumericCount = 0;
+            for (HistoryModel h : hList) {
+                if (h.getValue() == null || h.getValue().trim().isEmpty()) {
+                    continue;
+                }
+                try {
+                    numericValues.add(Double.parseDouble(h.getValue().trim()));
+                } catch (NumberFormatException e) {
+                    nonNumericCount++;
+                    enumDist.merge(h.getValue().trim(), 1L, (a, b) -> a + b);
+                }
+            }
+            vo.setNonNumericCount(nonNumericCount);
+
+            if (!numericValues.isEmpty()) {
+                double min = numericValues.stream().mapToDouble(Double::doubleValue).min().orElse(0);
+                double max = numericValues.stream().mapToDouble(Double::doubleValue).max().orElse(0);
+                int bucketCount = 10;
+                double range = max - min;
+                // 若所有值相同，设一个区间宽度
+                double bucketWidth = (range == 0) ? 1.0 : range / bucketCount;
+                long[] counts = new long[bucketCount];
+                for (double v : numericValues) {
+                    int idx = (range == 0) ? 0 : (int) Math.min((v - min) / bucketWidth, bucketCount - 1);
+                    counts[idx]++;
+                }
+                List<HistogramVO.Bucket> buckets = new ArrayList<>();
+                for (int i = 0; i < bucketCount; i++) {
+                    HistogramVO.Bucket bucket = new HistogramVO.Bucket();
+                    double lo = min + i * bucketWidth;
+                    double hi = min + (i + 1) * bucketWidth;
+                    bucket.setRangeMin(Math.round(lo * 100.0) / 100.0);
+                    bucket.setRangeMax(Math.round(hi * 100.0) / 100.0);
+                    bucket.setLabel(String.format("%.2f~%.2f", lo, hi));
+                    bucket.setCount(counts[i]);
+                    buckets.add(bucket);
+                }
+                vo.setBuckets(buckets);
+            } else if (!enumDist.isEmpty()) {
+                // 全部是枚举/布尔值，返回枚举分布
+                vo.setEnumDistribution(enumDist);
+                vo.setBuckets(new ArrayList<>());
+            } else {
+                vo.setBuckets(new ArrayList<>());
+            }
+            result.add(vo);
+        }
+        return result;
+    }
+
+    /**
+     * 公共辅助：按 SN 分组，构建 snToIdentifiers / identifierToModelName / identifierToSn
+     */
+    private void buildSnGrouping(DeviceHistoryParam param,
+                                  Map<String, List<DeviceHistoryParam.IdentifierVO>> snToIdentifiers,
+                                  Map<String, String> identifierToModelName,
+                                  Map<String, String> identifierToSn) {
+        if (CollectionUtils.isEmpty(param.getIdentifierList())) {
+            List<ThingsModelDTO> list = deviceService.listThingsModel(param.getDeviceId());
+            for (ThingsModelDTO dto : list) {
+                String sn = StringUtils.isNotEmpty(dto.getSerialNumber())
+                        ? dto.getSerialNumber() : param.getSerialNumber();
+                DeviceHistoryParam.IdentifierVO vo = new DeviceHistoryParam.IdentifierVO();
+                vo.setIdentifier(dto.getIdentifier());
+                vo.setType(dto.getType());
+                snToIdentifiers.computeIfAbsent(sn, k -> new ArrayList<>()).add(vo);
+                identifierToModelName.putIfAbsent(dto.getIdentifier(), dto.getModelName());
+                identifierToSn.putIfAbsent(dto.getIdentifier(), sn);
+            }
+        } else {
+            snToIdentifiers.put(param.getSerialNumber(), param.getIdentifierList());
+            param.getIdentifierList().forEach(vo -> {
+                identifierToSn.put(vo.getIdentifier(), param.getSerialNumber());
+            });
+        }
+    }
+
+    /**
+     * 公共辅助：按 snToIdentifiers 分组查询原始历史，返回 identifier -> List<HistoryModel>
+     *
+     * @param includeProperty 是否查属性日志（type=1）
+     * @param includeFunction 是否查功能日志（type=2）
+     */
+    private Map<String, List<HistoryModel>> fetchRawByIdentifier(DeviceHistoryParam param,
+            Map<String, List<DeviceHistoryParam.IdentifierVO>> snToIdentifiers,
+            boolean includeProperty, boolean includeFunction) {
+        Map<String, List<HistoryModel>> rawByIdentifier = new LinkedHashMap<>();
+        for (Map.Entry<String, List<DeviceHistoryParam.IdentifierVO>> entry : snToIdentifiers.entrySet()) {
+            String sn = entry.getKey();
+            List<DeviceHistoryParam.IdentifierVO> vos = entry.getValue();
+            if (includeProperty) {
+                List<String> propIds = vos.stream().filter(v -> Integer.valueOf(1).equals(v.getType()))
+                        .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
+                if (CollectionUtils.isNotEmpty(propIds)) {
+                    DeviceLog dl = new DeviceLog();
+                    dl.setSerialNumber(sn);
+                    dl.setIdentityList(propIds);
+                    dl.setBeginTime(param.getBeginTime());
+                    dl.setEndTime(param.getEndTime());
+                    for (HistoryModel h : deviceLogService.listHistory(dl)) {
+                        rawByIdentifier.computeIfAbsent(h.getIdentity(), k -> new ArrayList<>()).add(h);
+                    }
+                }
+            }
+            if (includeFunction) {
+                List<String> funcIds = vos.stream().filter(v -> Integer.valueOf(2).equals(v.getType()))
+                        .map(DeviceHistoryParam.IdentifierVO::getIdentifier).collect(Collectors.toList());
+                if (CollectionUtils.isNotEmpty(funcIds)) {
+                    FunctionLog fl = new FunctionLog();
+                    fl.setSerialNumber(sn);
+                    fl.setIdentifyList(funcIds);
+                    fl.setBeginTime(DateUtils.dateTime(DateUtils.YY_MM_DD_HH_MM_SS, param.getBeginTime()));
+                    fl.setEndTime(DateUtils.dateTime(DateUtils.YY_MM_DD_HH_MM_SS, param.getEndTime()));
+                    for (HistoryModel h : functionLogService.listHistory(fl)) {
+                        rawByIdentifier.computeIfAbsent(h.getIdentity(), k -> new ArrayList<>()).add(h);
+                    }
+                }
+            }
+        }
+        return rawByIdentifier;
+    }
+
     private Map<String, String> parseCrossDeviceRefs(String formula) {
         return CalculateUtils.parseCrossDeviceRefs(formula);
     }
 
+    @Override
+    public List<DeviceStatsVO> deviceStats(DeviceHistoryParam param) {
+        Map<String, List<DeviceHistoryParam.IdentifierVO>> snToIdentifiers = new LinkedHashMap<>();
+        Map<String, String> identifierToModelName = new LinkedHashMap<>();
+        Map<String, String> identifierToSn = new LinkedHashMap<>();
+        buildSnGrouping(param, snToIdentifiers, identifierToModelName, identifierToSn);
+
+        if (snToIdentifiers.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        Map<String, List<HistoryModel>> rawByIdentifier = fetchRawByIdentifier(param, snToIdentifiers, true, true);
+
+        // 计算每个 identifier 的统计指标
+        List<DeviceStatsVO> result = new ArrayList<>();
+        for (Map.Entry<String, String> entry : identifierToSn.entrySet()) {
+            String identifier = entry.getKey();
+            String sn = entry.getValue();
+            List<HistoryModel> hList = rawByIdentifier.getOrDefault(identifier, new ArrayList<>());
+
+            DeviceStatsVO vo = new DeviceStatsVO();
+            vo.setIdentifier(identifier);
+            vo.setModelName(identifierToModelName.getOrDefault(identifier, identifier));
+            vo.setSerialNumber(sn);
+            vo.setDataCount((long) hList.size());
+
+            if (!hList.isEmpty()) {
+                // listHistory 返回 desc 排序，第一条即最新
+                HistoryModel latest = hList.get(0);
+                vo.setLastValue(latest.getValue());
+                if (latest.getTime() != null) {
+                    vo.setLastTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, latest.getTime()));
+                }
+                // 数值统计
+                BigDecimal max = null, min = null, sum = BigDecimal.ZERO;
+                int numCount = 0;
+                for (HistoryModel h : hList) {
+                    if (h.getValue() == null || h.getValue().isEmpty()) {
+                        continue;
+                    }
+                    try {
+                        BigDecimal v = new BigDecimal(h.getValue().trim());
+                        if (max == null || v.compareTo(max) > 0) {
+                            max = v;
+                        }
+                        if (min == null || v.compareTo(min) < 0) {
+                            min = v;
+                        }
+                        sum = sum.add(v);
+                        numCount++;
+                    } catch (NumberFormatException ignored) {
+                        // 非数值型（布尔、枚举、字符串等）跳过数值计算
+                    }
+                }
+                if (numCount > 0) {
+                    vo.setMaxValue(stripTrailingZeros(max));
+                    vo.setMinValue(stripTrailingZeros(min));
+                    vo.setAvgValue(stripTrailingZeros(sum.divide(BigDecimal.valueOf(numCount), 4, RoundingMode.HALF_UP)));
+                    vo.setSumValue(stripTrailingZeros(sum));
+                }
+            }
+            result.add(vo);
+        }
+        return result;
+    }
+
+    private String stripTrailingZeros(BigDecimal value) {
+        if (value == null) {
+            return null;
+        }
+        return value.stripTrailingZeros().toPlainString();
+    }
+
     private List<Date> buildMinuteSlots(String beginTime, String endTime) {
         Date start = DateUtils.parseDate(beginTime);
         Date end = DateUtils.parseDate(endTime);
diff --git a/yack-web/src/api/data/center.js b/yack-web/src/api/data/center.js
index 1e80e3b7..f89336b6 100644
--- a/yack-web/src/api/data/center.js
+++ b/yack-web/src/api/data/center.js
@@ -45,6 +45,33 @@ export function getDataCenterCountThingsModelInvoke(query) {
     });
 }
 
+// 查询设备物模型统计指标（最大/最小/均值/累计/数据量/最新值）
+export function getDataCenterDeviceStats(data) {
+    return request({
+        url: '/data/center/deviceStats',
+        method: 'post',
+        data: data,
+    });
+}
+
+// 数据质量分析（上报间隔、缺数时间段、重复值检测、质量评分、7×24热力图）
+export function getDataCenterDeviceDataQuality(data) {
+    return request({
+        url: '/data/center/deviceDataQuality',
+        method: 'post',
+        data: data,
+    });
+}
+
+// 值分布直方图
+export function getDataCenterDeviceHistogram(data) {
+    return request({
+        url: '/data/center/deviceHistogram',
+        method: 'post',
+        data: data,
+    });
+}
+
 // 导出设备历史数据Excel
 export function exportDeviceHistory(data) {
     return request({
diff --git a/yack-web/src/views/dataCenter/analysis.vue b/yack-web/src/views/dataCenter/analysis.vue
index 47c1941d..119e19d7 100644
--- a/yack-web/src/views/dataCenter/analysis.vue
+++ b/yack-web/src/views/dataCenter/analysis.vue
@@ -1,592 +1,397 @@
 <template>
     <div class="data-center-analysis">
+        <!-- 筛选栏 -->
         <el-card style="margin-bottom: 12px">
             <el-form :model="queryParams" ref="queryForm" :inline="true" size="mini" label-width="68px" style="margin-bottom: -18px">
-                <el-form-item :label="$t('dataCenter.analysis.349202-0')" prop="deviceId">
-                    <el-select v-model="queryParams.deviceId" :placeholder="$t('dataCenter.analysis.349202-1')" filterable @change="handleDevDeviceChange">
-                        <el-option v-for="(item, index) in deviceList" :key="index" :label="item.deviceName" :value="item.deviceId"></el-option>
+                <el-form-item label="设备名称" prop="deviceId">
+                    <el-select v-model="queryParams.deviceId" placeholder="请选择设备" filterable @change="handleDeviceChange" style="width: 200px">
+                        <el-option v-for="item in deviceList" :key="item.deviceId" :label="item.deviceName" :value="item.deviceId"></el-option>
                     </el-select>
                 </el-form-item>
-                <el-form-item :label="$t('dataCenter.analysis.349202-2')" prop="dayDaterange">
+                <el-form-item label="时间范围" prop="dayDaterange">
                     <el-date-picker
-                        style="width: 315px"
+                        style="width: 340px"
                         v-model="queryParams.dayDaterange"
                         value-format="yyyy-MM-dd HH:mm:ss"
                         type="datetimerange"
                         range-separator="-"
-                        :start-placeholder="$t('dataCenter.analysis.349202-4')"
-                        :end-placeholder="$t('dataCenter.analysis.349202-5')"
+                        start-placeholder="开始时间"
+                        end-placeholder="结束时间"
                         :picker-options="pickerOptions"
                     ></el-date-picker>
                 </el-form-item>
                 <el-form-item style="float: right">
-                    <el-button type="primary" icon="el-icon-search" size="mini" @click="handleQuery">{{ $t('dataCenter.analysis.349202-5') }}</el-button>
-                    <el-button icon="el-icon-refresh" size="mini" @click="handleResetQuery">{{ $t('dataCenter.analysis.349202-6') }}</el-button>
+                    <el-button type="primary" icon="el-icon-search" size="mini" @click="handleQuery" :loading="loading">查询</el-button>
+                    <el-button icon="el-icon-refresh" size="mini" @click="handleResetQuery">重置</el-button>
                 </el-form-item>
             </el-form>
         </el-card>
 
-        <el-row :gutter="20" v-loading="loading">
-            <el-col :span="16">
-                <el-card class="card-box" style="margin-bottom: 20px">
-                    <div v-show="deviceLineList.length !== 0" ref="deviceLineChart" style="width: 100%; height: 400px"></div>
-                    <el-empty v-if="deviceLineList.length === 0" style="height: 400px" :description="$t('dataCenter.analysis.349202-7')"></el-empty>
-                </el-card>
-            </el-col>
+        <div v-loading="loading">
+            <!-- ① 统计指标卡片 -->
+            <template v-if="statsList.length > 0">
+                <div class="section-title"><i class="el-icon-data-analysis"></i> 统计指标 <span class="section-sub">{{ timeRangeLabel }}</span></div>
+                <el-row :gutter="16" style="margin-bottom: 20px">
+                    <el-col :span="24" v-for="stat in statsList" :key="'stat-'+stat.identifier" style="margin-bottom: 12px">
+                        <el-card shadow="hover" class="stat-card">
+                            <div class="stat-card-header">
+                                <span class="stat-name">{{ stat.modelName || stat.identifier }}</span>
+                                <el-tag v-if="stat.serialNumber" size="mini" type="info" style="margin-left: 8px">{{ stat.serialNumber }}</el-tag>
+                                <span class="stat-count">共 {{ stat.dataCount }} 条</span>
+                            </div>
+                            <el-row :gutter="10">
+                                <el-col :span="4"><div class="metric metric-max"><div class="ml">最大值</div><div class="mv">{{ formatNum(stat.maxValue) }}</div></div></el-col>
+                                <el-col :span="4"><div class="metric metric-min"><div class="ml">最小值</div><div class="mv">{{ formatNum(stat.minValue) }}</div></div></el-col>
+                                <el-col :span="4"><div class="metric metric-avg"><div class="ml">平均值</div><div class="mv">{{ formatNum(stat.avgValue) }}</div></div></el-col>
+                                <el-col :span="4"><div class="metric metric-sum"><div class="ml">累计值</div><div class="mv">{{ formatNum(stat.sumValue) }}</div></div></el-col>
+                                <el-col :span="4"><div class="metric metric-last"><div class="ml">最新值</div><div class="mv">{{ formatNum(stat.lastValue) }}</div><div class="mt">{{ stat.lastTime || '' }}</div></div></el-col>
+                                <el-col :span="4"><div class="metric metric-count"><div class="ml">数据量</div><div class="mv">{{ stat.dataCount }}</div></div></el-col>
+                            </el-row>
+                        </el-card>
+                    </el-col>
+                </el-row>
+            </template>
 
-            <el-col :span="8">
-                <el-card class="card-box" style="margin-bottom: 20px">
-                    <div v-show="alertProcessList.length !== 0" ref="alertProcessPieChart" style="width: 100%; height: 400px"></div>
-                    <el-empty v-if="alertProcessList.length === 0" style="height: 400px" :description="$t('dataCenter.analysis.349202-7')"></el-empty>
-                </el-card>
-            </el-col>
+            <!-- ② 数据质量面板 -->
+            <template v-if="qualityList.length > 0">
+                <div class="section-title"><i class="el-icon-monitor"></i> 数据质量 <span class="section-sub">{{ timeRangeLabel }}</span></div>
+                <el-row :gutter="16" style="margin-bottom: 20px">
+                    <el-col :span="24" v-for="q in qualityList" :key="'q-'+q.identifier" style="margin-bottom: 12px">
+                        <el-card shadow="hover">
+                            <!-- 头部：名称 + 质量分 + 基础指标 -->
+                            <div class="quality-header">
+                                <span class="stat-name">{{ q.modelName || q.identifier }}</span>
+                                <el-tag v-if="q.serialNumber" size="mini" type="info" style="margin-left: 8px">{{ q.serialNumber }}</el-tag>
+                                <div class="quality-score-wrap">
+                                    <span class="quality-score-label">质量评分</span>
+                                    <span class="quality-score" :class="scoreClass(q.qualityScore)">{{ q.qualityScore }}</span>
+                                </div>
+                                <div class="quality-meta">
+                                    <span class="meta-item"><i class="el-icon-time"></i> 均值间隔 {{ formatInterval(q.avgIntervalSeconds) }}</span>
+                                    <span class="meta-item" :class="q.missingCount > 0 ? 'text-warn' : 'text-ok'">
+                                        <i class="el-icon-warning-outline"></i> 缺数 {{ q.missingCount }} 段 / {{ q.totalMissingMinutes }} 分钟
+                                    </span>
+                                    <span class="meta-item" :class="q.repeatRate > 10 ? 'text-warn' : 'text-ok'">
+                                        <i class="el-icon-refresh"></i> 连续重复率 {{ q.repeatRate }}%
+                                    </span>
+                                    <span class="meta-item"><i class="el-icon-document"></i> 数据量 {{ q.totalCount }}</span>
+                                </div>
+                            </div>
+                            <el-row :gutter="16" style="margin-top: 16px">
+                                <!-- 缺数时间段 -->
+                                <el-col :span="12">
+                                    <div class="sub-title">缺数时间段</div>
+                                    <div v-if="q.missingSegments && q.missingSegments.length > 0" class="missing-list">
+                                        <div v-for="(seg, idx) in q.missingSegments.slice(0, 10)" :key="idx" class="missing-item">
+                                            <el-tag size="mini" type="danger" style="margin-right: 6px">{{ seg.durationMinutes }} 分钟</el-tag>
+                                            <span class="missing-time">{{ seg.gapStart }} → {{ seg.gapEnd }}</span>
+                                        </div>
+                                        <div v-if="q.missingSegments.length > 10" class="more-tip">... 还有 {{ q.missingSegments.length - 10 }} 段</div>
+                                    </div>
+                                    <el-empty v-else description="无缺数，数据连续" :image-size="50" style="padding: 10px 0"></el-empty>
+                                </el-col>
+                                <!-- 7×24 热力图 -->
+                                <el-col :span="12">
+                                    <div class="sub-title">7×24 上报热力图 <span style="font-size: 11px; color: #909399">（颜色越深上报越密集）</span></div>
+                                    <div :ref="'heatmap-' + q.identifier" style="width: 100%; height: 180px"></div>
+                                </el-col>
+                            </el-row>
+                        </el-card>
+                    </el-col>
+                </el-row>
+            </template>
 
-            <el-col :span="8">
-                <el-card class="card-box" style="margin-bottom: 0">
-                    <div v-show="deviceBarList.length !== 0" ref="deviceBarChart" style="width: 100%; height: 480px"></div>
-                    <el-empty v-if="deviceBarList.length === 0" style="height: 480px" :description="$t('dataCenter.analysis.349202-7')"></el-empty>
-                </el-card>
-            </el-col>
+            <!-- ③ 值分布直方图 -->
+            <template v-if="histogramList.length > 0">
+                <div class="section-title"><i class="el-icon-histogram"></i> 值分布直方图 <span class="section-sub">{{ timeRangeLabel }}</span></div>
+                <el-row :gutter="16" style="margin-bottom: 20px">
+                    <el-col :span="12" v-for="h in histogramList" :key="'hist-'+h.identifier" style="margin-bottom: 16px">
+                        <el-card shadow="hover">
+                            <div class="stat-name" style="margin-bottom: 12px">
+                                {{ h.modelName || h.identifier }}
+                                <el-tag v-if="h.serialNumber" size="mini" type="info" style="margin-left: 6px">{{ h.serialNumber }}</el-tag>
+                            </div>
+                            <!-- 数值型：柱状直方图 -->
+                            <template v-if="h.buckets && h.buckets.length > 0">
+                                <div :ref="'hist-' + h.identifier" style="width: 100%; height: 220px"></div>
+                            </template>
+                            <!-- 枚举/布尔型：饼图 -->
+                            <template v-else-if="h.enumDistribution && Object.keys(h.enumDistribution).length > 0">
+                                <div :ref="'hist-' + h.identifier" style="width: 100%; height: 220px"></div>
+                            </template>
+                            <el-empty v-else description="无可分析数据" :image-size="50"></el-empty>
+                        </el-card>
+                    </el-col>
+                </el-row>
+            </template>
 
-            <el-col :span="8">
-                <el-card class="card-box" style="margin-bottom: 0">
-                    <dv-scroll-board v-show="realTimeConfig.data && realTimeConfig.data.length !== 0" class="scroll-board-wrap" :config="realTimeConfig" style="width: 100%; height: 480px" />
-                    <el-empty v-if="!realTimeConfig.data || realTimeConfig.data.length === 0" style="height: 480px" :description="$t('dataCenter.analysis.349202-7')"></el-empty>
-                </el-card>
-            </el-col>
+            <!-- ④ 折线图（原有不动） -->
+            <el-card class="card-box">
+                <div slot="header" class="chart-header"><i class="el-icon-trend-charts"></i> 历史趋势折线图</div>
+                <div v-show="deviceLineList.length !== 0" ref="deviceLineChart" style="width: 100%; height: 420px"></div>
+                <el-empty v-if="deviceLineList.length === 0" style="height: 420px" description="暂无数据，请选择设备后点击查询"></el-empty>
+            </el-card>
 
-            <el-col :span="8">
-                <el-card class="card-box" style="margin-bottom: 0">
-                    <dv-scroll-board v-show="alertInfoConfig.data && alertInfoConfig.data.length !== 0" class="scroll-board-wrap" :config="alertInfoConfig" style="width: 100%; height: 265px; margin-bottom: 15px" />
-                    <el-empty v-if="!alertInfoConfig.data || alertInfoConfig.data.length === 0" style="height: 265px; margin-bottom: 15px" :image-size="120" :description="$t('dataCenter.analysis.349202-7')"></el-empty>
-                    <div v-show="alertLevelPieList.length !== 0" ref="alertPieChart" style="width: 100%; height: 200px"></div>
-                    <el-empty v-if="alertLevelPieList.length === 0" style="height: 200px" :image-size="120" :description="$t('dataCenter.analysis.349202-7')"></el-empty>
-                </el-card>
-            </el-col>
-        </el-row>
+            <!-- 初始空状态 -->
+            <el-card v-if="!queried" style="margin-top: 16px; text-align: center; padding: 40px 0">
+                <el-empty description="请选择设备和时间范围，然后点击查询" :image-size="100"></el-empty>
+            </el-card>
+        </div>
     </div>
 </template>
 
 <script>
 import moment from 'moment';
 import { listDeviceShort, listThingsModel } from '@/api/iot/device.js';
-import { getDataCenterDeviceHistory, getDataCenterCountAlertProcess, getDataCenterCountAlertLevel, getDataCenterCountThingsModelInvoke } from '@/api/data/center.js';
-import { listAlertLog } from '@/api/iot/alertLog';
+import {
+    getDataCenterDeviceHistory,
+    getDataCenterDeviceStats,
+    getDataCenterDeviceDataQuality,
+    getDataCenterDeviceHistogram,
+} from '@/api/data/center.js';
+
+const WEEK_LABELS = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
+const HOUR_LABELS = Array.from({ length: 24 }, (_, i) => `${i}时`);
 
 export default {
     name: 'dataCenterAnalysis',
-    dicts: ['iot_process_status', 'iot_alert_level'],
     data() {
         return {
             loading: false,
-            loadingCount: 0,
+            pendingCount: 0,
+            queried: false,
             deviceList: [],
-            identifierList: [], // 属性列表
+            identifierList: [],
             pickerOptions: {
                 shortcuts: [
-                    {
-                        text: this.$t('dataCenter.analysis.349202-8'),
-                        onClick(picker) {
-                            const end = new Date();
-                            const start = new Date();
-                            start.setTime(start.getTime() - 3600 * 200 * 2);
-                            picker.$emit('pick', [start, end]);
-                        },
-                    },
-                    {
-                        text: this.$t('dataCenter.analysis.349202-9'),
-                        onClick(picker) {
-                            const end = new Date();
-                            const start = new Date();
-                            start.setTime(start.getTime() - 3600 * 200 * 24);
-                            picker.$emit('pick', [start, end]);
-                        },
-                    },
-                    {
-                        text: this.$t('dataCenter.analysis.349202-10'),
-                        onClick(picker) {
-                            const end = new Date();
-                            const start = new Date();
-                            start.setTime(start.getTime() - 3600 * 200 * 24 * 7);
-                            picker.$emit('pick', [start, end]);
-                        },
-                    },
-                    {
-                        text: this.$t('dataCenter.analysis.349202-11'),
-                        onClick(picker) {
-                            const end = new Date();
-                            const start = new Date();
-                            start.setTime(start.getTime() - 3600 * 200 * 24 * 30);
-                            picker.$emit('pick', [start, end]);
-                        },
-                    },
+                    { text: '近2小时', onClick(p) { const e = new Date(); const s = new Date(e.getTime() - 7200000); p.$emit('pick', [s, e]); } },
+                    { text: '近1天',   onClick(p) { const e = new Date(); const s = new Date(e.getTime() - 86400000); p.$emit('pick', [s, e]); } },
+                    { text: '近7天',   onClick(p) { const e = new Date(); const s = new Date(e.getTime() - 604800000); p.$emit('pick', [s, e]); } },
+                    { text: '近30天',  onClick(p) { const e = new Date(); const s = new Date(e.getTime() - 2592000000); p.$emit('pick', [s, e]); } },
                 ],
             },
-            // 查询参数
             queryParams: {
                 deviceId: null,
-                dayDaterange: [new Date(new Date().getTime() - 3600 * 200 * 2), new Date()],
+                dayDaterange: [new Date(new Date().getTime() - 7200000), new Date()],
             },
-            deviceLineList: [], // 设备折线图数据
-            alertProcessList: [], // 信息饼图数据列表
-            deviceBarList: [], // 设备柱状数据列表
-            realTimeConfig: {}, // 实时数据
-            alertInfoConfig: {},
-            alertLevelPieList: [], // 告警饼图数据列表
+            // 数据
+            deviceLineList: [],
+            statsList: [],
+            qualityList: [],
+            histogramList: [],
         };
     },
+    computed: {
+        timeRangeLabel() {
+            if (!this.queryParams.dayDaterange || this.queryParams.dayDaterange.length < 2) return '';
+            return `${moment(this.queryParams.dayDaterange[0]).format('MM-DD HH:mm')} ~ ${moment(this.queryParams.dayDaterange[1]).format('MM-DD HH:mm')}`;
+        },
+    },
     mounted() {
         this.getDeviceList();
     },
     methods: {
-        // 获取设备列表
         getDeviceList() {
-            const params = {
-                showChild: true,
-                pageNum: 1,
-                pageSize: 9999,
-            };
-            listDeviceShort(params).then((res) => {
-                if (res.code === 200) {
-                    this.deviceList = res.rows;
-                }
+            listDeviceShort({ showChild: true, pageNum: 1, pageSize: 9999 }).then((res) => {
+                if (res.code === 200) this.deviceList = res.rows;
             });
         },
-        // 选择设备后
-        handleDevDeviceChange(val) {
-            this.getDevIdentifierList(val);
-        },
-        getDevIdentifierList(deviceId) {
-            const params = {
-                deviceId: deviceId,
-                pageNum: 1,
-                pageSize: 9999,
-            };
-            listThingsModel(params).then((res) => {
-                if (res.code === 200) {
-                    this.identifierList = res.rows;
-                }
-            });
-        },
-        // 查询设备的历史数据
-        getDevChartDatas() {
-            const devices = this.deviceList.find((item) => item.deviceId === this.queryParams.deviceId);
-            if (!devices) {
-                return;
-            }
-            this.myLoading();
-            const params = {
-                deviceId: devices.deviceId,
-                serialNumber: devices.serialNumber,
-                beginTime: moment(this.queryParams.dayDaterange[0]).format('YYYY-MM-DD HH:mm:ss'),
-                endTime: moment(this.queryParams.dayDaterange[1]).format('YYYY-MM-DD HH:mm:ss'),
-            };
-            getDataCenterDeviceHistory(params).then((res) => {
-                if (res.code === 200) {
-                    this.deviceLineList = res.data;
-                    if (this.deviceLineList.length !== 0) {
-                        setTimeout(() => {
-                            this.drawDevLineChart();
-                        }, 200);
-                    }
-                }
-                this.myLoadingClose();
-            });
-        },
-        // 折线图
-        drawDevLineChart() {
-            this.deviceLineChart = this.$echarts.init(this.$refs.deviceLineChart);
-            this.deviceLineChart.clear();
-            // 设置折线图数据和样式
-            this.deviceLineChart.setOption({
-                tooltip: {
-                    trigger: 'axis',
-                },
-                legend: {
-                    align: 'right',
-                    left: '3%',
-                    top: '6%',
-                },
-                grid: {
-                    top: '20%',
-                    left: '5%',
-                    right: '5%',
-                    bottom: '5%',
-                    containLabel: true,
-                },
-                // 自定义：设置x轴刻度
-                xAxis: {
-                    type: 'category',
-                    boundaryGap: true,
-                    axisTick: {
-                        alignWithLabel: true,
-                    },
-                    // 自定义标签
-                    data: this.deviceLineList.length !== 0 && this.deviceLineList.map((item) => Object.keys(item)[0]),
-                },
-                // 自定义：设置y轴刻度
-                yAxis: {
-                    type: 'value',
-                    scale: true, //自适应
-                },
-                // 设置数据
-                series: this.getDevSeries(),
-            });
-        },
-        // 获取设备的series
-        getDevSeries() {
-            if (this.deviceLineList && this.deviceLineList.length !== 0) {
-                const identifiers = Object.values(this.deviceLineList[0])[0].map((item) => Object.keys(item)[0]) || [];
-                return identifiers.map((item) => {
-                    return {
-                        name: this.identifierList.find((chil) => chil.identifier === item).modelName,
-                        type: 'line',
-                        //stack: this.$t('dataCenter.analysis.349202-12'),
-                        smooth: true,
-                        data: this.deviceLineList.map((d) => {
-                            const ide = Object.values(d)[0].find((f) => Object.keys(f)[0] === item);
-                            return Object.values(ide)[0];
-                        }),
-                    };
+        handleDeviceChange(val) {
+            this.identifierList = [];
+            this.clearData();
+            if (val) {
+                listThingsModel({ deviceId: val, pageNum: 1, pageSize: 9999 }).then((res) => {
+                    if (res.code === 200) this.identifierList = res.rows;
                 });
             }
         },
-        // 查询统计告警信息处理
-        getCountAlertProcess() {
-            const devices = this.deviceList.find((item) => item.deviceId === this.queryParams.deviceId);
-            if (!devices) {
-                return;
-            }
-            this.myLoading();
-            const params = {
-                serialNumber: devices.serialNumber,
-                beginTime: moment(this.queryParams.dayDaterange[0]).format('YYYY-MM-DD HH:mm:ss'),
-                endTime: moment(this.queryParams.dayDaterange[1]).format('YYYY-MM-DD HH:mm:ss'),
-            };
-            getDataCenterCountAlertProcess(params).then((res) => {
-                if (res.code === 200) {
-                    this.alertProcessList = res.data;
-                    if (this.alertProcessList.length !== 0) {
-                        setTimeout(() => {
-                            this.drawAlertProcessPieChart();
-                        }, 200);
-                    }
-                }
-                this.myLoadingClose();
-            });
+        clearData() {
+            this.deviceLineList = [];
+            this.statsList = [];
+            this.qualityList = [];
+            this.histogramList = [];
         },
-        // 饼图
-        drawAlertProcessPieChart() {
-            this.alertProcessPieChart = this.$echarts.init(this.$refs.alertProcessPieChart);
-            this.alertProcessPieChart.clear();
-            this.alertProcessPieChart.setOption({
-                title: {
-                    text: this.$t('dataCenter.analysis.349202-13'),
-                    left: 'center',
-                },
-                tooltip: {
-                    trigger: 'item',
-                },
-                legend: {
-                    show: true,
-                    x: 'center',
-                    y: 'bottom',
-                    padding: [0, 0, 12, 0],
-                },
-                color: ['#5470C6', '#91CC75', '#73C0DE', '#FAC858', '#EE6666'],
-                series: [
-                    {
-                        type: 'pie',
-                        radius: '70%',
-                        center: ['50%', '49%'],
-                        labelLine: {
-                            show: true,
-                            smooth: true, // 设置平滑曲线
-                            length: 10, // 设置牵引线长度
-                            length2: 10,
-                        },
-                        label: {
-                            // 设置标签显示信息和格式
-                            show: true,
-                            position: 'outer',
-                            fontSize: 11,
-                            color: '#1d1d1d',
-                            formatter: function (params) {
-                                return `${params.name}：${params.value}个\n占：${params.percent}%`;
-                            },
-                        },
-                        data: this.getAlertPieProcessData(),
-                    },
-                ],
-            });
-        },
-        getAlertPieProcessData() {
-            if (this.alertProcessList && this.alertProcessList.length !== 0) {
-                return this.alertProcessList.map((item) => {
-                    return {
-                        name: this.dict.type.iot_process_status.find((chil) => chil.value === String(item.type)).label,
-                        value: item.count,
-                    };
-                });
-            }
-        },
-        // 获取设备物模型指令下发数量
-        getThingsModelInvoke() {
-            const devices = this.deviceList.find((item) => item.deviceId === this.queryParams.deviceId);
-            if (!devices) {
-                return;
-            }
-            this.myLoading();
-            const params = {
-                serialNumber: devices.serialNumber,
-                beginTime: moment(this.queryParams.dayDaterange[0]).format('YYYY-MM-DD HH:mm:ss'),
-                endTime: moment(this.queryParams.dayDaterange[1]).format('YYYY-MM-DD HH:mm:ss'),
-            };
-            getDataCenterCountThingsModelInvoke(params).then((res) => {
-                if (res.code === 200) {
-                    this.deviceBarList = res.data;
-                    if (this.deviceBarList.length !== 0) {
-                        setTimeout(() => {
-                            this.drawDeviceBarChart();
-                        }, 200);
-                    }
-                }
-                this.myLoadingClose();
-            });
-        },
-        // 柱状图
-        drawDeviceBarChart() {
-            this.deviceBarChart = this.$echarts.init(this.$refs.deviceBarChart);
-            this.deviceBarChart.clear();
-            this.deviceBarChart.setOption({
-                title: {
-                    text: this.$t('dataCenter.analysis.349202-14'),
-                    left: 'center',
-                },
-                color: ['#1890FF'],
-                textStyle: {
-                    fontSize: 12,
-                    fontStyle: 'normal',
-                },
-                grid: {
-                    top: '10%',
-                    left: '1%',
-                    right: '6%',
-                    bottom: '5%',
-                    containLabel: true,
-                    borderWidth: 0,
-                },
-                xAxis: {
-                    type: 'value',
-                    axisLine: {
-                        show: true,
-                        lineStyle: {
-                            color: '#fefef',
-                        },
-                    },
-                    axisLabel: {
-                        show: true,
-                        interval: 0,
-                        formatter: function (val) {
-                            return `${val}次`;
-                        },
-                    },
-                },
-                yAxis: {
-                    axisLine: {
-                        show: true,
-                        lineStyle: {
-                            color: '#fefef',
-                        },
-                    },
-                    type: 'category',
-                    data: this.deviceBarList.length !== 0 && this.deviceBarList.map((item) => item.modelName),
-                },
-                series: [
-                    {
-                        itemStyle: {
-                            normal: {
-                                label: {
-                                    show: true,
-                                    position: 'right',
-                                },
-                            },
-                            backgroundStyle: {
-                                color: '#EBEEF5',
-                            },
-                        },
-                        data: this.deviceBarList.length !== 0 && this.deviceBarList.map((item) => item.count),
-                        type: 'bar',
-                        barWidth: 30, //柱图宽度
-                    },
-                ],
-            });
-        },
-        // 查询告警信息
-        getDataRealTimeUpload() {
-            if (!this.queryParams.deviceId) {
-                return;
-            }
-            this.myLoading();
-            const params = {
-                deviceId: this.queryParams.deviceId,
-                pageNum: 1,
-                pageSize: 9999,
-            };
-            listThingsModel(params).then((res) => {
-                if (res.code === 200) {
-                    const header = [this.$t('dataCenter.analysis.349202-15'), this.$t('dataCenter.analysis.349202-16'), this.$t('dataCenter.analysis.349202-17')];
-                    let data = [];
-                    if (res.rows && res.rows.length !== 0) {
-                        data = res.rows.map((item) => {
-                            return [item.modelName, item.value, item.ts];
-                        });
-                    }
-                    this.realTimeConfig = {
-                        rowNum: 10,
-                        columnWidth: [100, 80, 190],
-                        header: header,
-                        data: data,
-                    };
-                }
-                this.myLoadingClose();
-            });
-        },
-        // 查询告警信息
-        getAlertInfo() {
-            const devices = this.deviceList.find((item) => item.deviceId === this.queryParams.deviceId);
-            if (!devices) {
-                return;
-            }
-            this.myLoading();
-            const params = {
-                serialNumber: devices.serialNumber,
-                pageNum: 1,
-                pageSize: 9999,
-            };
-            listAlertLog(params).then((res) => {
-                const header = [this.$t('dataCenter.analysis.349202-18'), this.$t('dataCenter.analysis.349202-19'), this.$t('dataCenter.analysis.349202-20')];
-                let data = [];
-                if (res.rows && res.rows.length !== 0) {
-                    data = res.rows.map((item) => {
-                        return [item.alertName, this.dict.type.iot_alert_level.find((chil) => chil.value === String(item.alertLevel)).label, item.createTime];
-                    });
-                }
-                this.alertInfoConfig = {
-                    rowNum: 5,
-                    columnWidth: [90, 90, 180],
-                    header: header,
-                    data: data,
-                };
-                this.myLoadingClose();
-            });
-        },
-        // 查询统计告警信息级别
-        getCountAlertLevel() {
-            const devices = this.deviceList.find((item) => item.deviceId === this.queryParams.deviceId);
-            if (!devices) {
-                return;
-            }
-            this.myLoading();
-            const params = {
-                serialNumber: devices.serialNumber,
-            };
-            getDataCenterCountAlertLevel(params).then((res) => {
-                if (res.code === 200) {
-                    this.alertLevelPieList = res.data;
-                    if (this.alertLevelPieList.length !== 0) {
-                        setTimeout(() => {
-                            this.drawAlertLevelPieChart();
-                        }, 200);
-                    }
-                }
-                this.myLoadingClose();
-            });
-        },
-        // 告警饼图
-        drawAlertLevelPieChart() {
-            this.alertPieChart = this.$echarts.init(this.$refs.alertPieChart);
-            this.alertPieChart.clear();
-            this.alertPieChart.setOption({
-                tooltip: {
-                    trigger: 'item',
-                },
-                legend: {
-                    show: true,
-                    x: 'center',
-                    y: 'bottom',
-                    padding: [14, 0, 0, 0],
-                },
-                color: ['#5470C6', '#91CC75', '#73C0DE', '#FAC858', '#EE6666'],
-                series: [
-                    {
-                        type: 'pie',
-                        radius: ['40%', '70%'],
-                        center: ['50%', '44%'],
-                        labelLine: {
-                            show: true,
-                            smooth: true, // 设置平滑曲线
-                            length: 10, // 设置牵引线长度
-                            length2: 10,
-                        },
-                        label: {
-                            // 设置标签显示信息和格式
-                            show: true,
-                            position: 'outer',
-                            fontSize: 11,
-                            color: '#1d1d1d',
-                            formatter: function (params) {
-                                return `${params.name}：${params.value}个\n占：${params.percent}%`;
-                            },
-                        },
-                        data: this.getAlertLevelPieData(),
-                    },
-                ],
-            });
-        },
-        getAlertLevelPieData() {
-            if (this.alertLevelPieList && this.alertLevelPieList.length !== 0) {
-                return this.alertLevelPieList.map((item) => {
-                    return {
-                        name: this.dict.type.iot_alert_level.find((chil) => chil.value === String(item.type)).label,
-                        value: item.count,
-                    };
-                });
-            }
-        },
-        // 搜索按钮操作
         handleQuery() {
-            this.getDevChartDatas(); // 查询设备的历史数据
-            this.getCountAlertProcess(); // 查询告警统计数据
-            this.getThingsModelInvoke(); // 设备使用统计
-            this.getDataRealTimeUpload(); // 获取数据实时上传
-            this.getAlertInfo(); // 查询告警信息
-            this.getCountAlertLevel(); // 查询告警级别统计
+            if (!this.queryParams.deviceId) { this.$message.warning('请先选择设备'); return; }
+            if (!this.queryParams.dayDaterange || this.queryParams.dayDaterange.length < 2) { this.$message.warning('请选择查询时间范围'); return; }
+            this.queried = true;
+            this.clearData();
+            this.fetchLineChart();
+            this.fetchStats();
+            this.fetchDataQuality();
+            this.fetchHistogram();
         },
-        // 重置按钮操作
         handleResetQuery() {
             this.resetForm('queryForm');
-            this.deviceLineList = [];
-            this.alertProcessList = [];
-            this.deviceBarList = [];
-            this.realTimeConfig = {};
-            this.alertInfoConfig = {};
-            this.alertLevelPieList = [];
+            this.clearData();
+            this.queried = false;
             this.loading = false;
-            this.loadingCount = 0;
+            this.pendingCount = 0;
         },
-        myLoading() {
-            if (this.loading === false) {
-                this.loading = true;
-            }
+        startLoading() { this.pendingCount++; this.loading = true; },
+        endLoading() {
+            this.pendingCount = Math.max(0, this.pendingCount - 1);
+            if (this.pendingCount === 0) this.loading = false;
         },
-        myLoadingClose() {
-            if (this.loadingCount === 5) {
-                this.loadingCount = 0;
-                this.loading = false;
-                return;
-            }
-            this.loadingCount = this.loadingCount + 1;
+        buildParams() {
+            const device = this.deviceList.find((d) => d.deviceId === this.queryParams.deviceId);
+            if (!device) return null;
+            return {
+                deviceId: device.deviceId,
+                serialNumber: device.serialNumber,
+                beginTime: moment(this.queryParams.dayDaterange[0]).format('YYYY-MM-DD HH:mm:ss'),
+                endTime: moment(this.queryParams.dayDaterange[1]).format('YYYY-MM-DD HH:mm:ss'),
+            };
+        },
+
+        // ── 折线图（原有逻辑不变）──
+        fetchLineChart() {
+            const params = this.buildParams();
+            if (!params) return;
+            this.startLoading();
+            getDataCenterDeviceHistory(params)
+                .then((res) => {
+                    if (res.code === 200) {
+                        this.deviceLineList = res.data || [];
+                        if (this.deviceLineList.length) setTimeout(() => this.drawLineChart(), 200);
+                    }
+                })
+                .finally(() => this.endLoading());
+        },
+        drawLineChart() {
+            const chart = this.$echarts.init(this.$refs.deviceLineChart);
+            chart.clear();
+            chart.setOption({
+                tooltip: { trigger: 'axis' },
+                legend: { align: 'right', left: '3%', top: '6%' },
+                grid: { top: '20%', left: '5%', right: '5%', bottom: '5%', containLabel: true },
+                xAxis: { type: 'category', boundaryGap: true, axisTick: { alignWithLabel: true }, data: this.deviceLineList.map((item) => Object.keys(item)[0]) },
+                yAxis: { type: 'value', scale: true },
+                series: this.buildLineSeries(),
+            });
+        },
+        buildLineSeries() {
+            if (!this.deviceLineList.length) return [];
+            const identifiers = Object.values(this.deviceLineList[0])[0].map((item) => Object.keys(item)[0]);
+            return identifiers.map((id) => ({
+                name: (this.identifierList.find((m) => m.identifier === id) || {}).modelName || id,
+                type: 'line',
+                smooth: true,
+                data: this.deviceLineList.map((d) => {
+                    const item = Object.values(d)[0].find((f) => Object.keys(f)[0] === id);
+                    if (!item) return null;
+                    const v = Object.values(item)[0];
+                    const num = Number(v);
+                    return isNaN(num) ? null : parseFloat(num.toFixed(6));
+                }),
+            }));
+        },
+
+        // ── 统计指标 ──
+        fetchStats() {
+            const params = this.buildParams();
+            if (!params) return;
+            this.startLoading();
+            getDataCenterDeviceStats(params)
+                .then((res) => { if (res.code === 200) this.statsList = res.data || []; })
+                .finally(() => this.endLoading());
+        },
+
+        // ── 数据质量 ──
+        fetchDataQuality() {
+            const params = this.buildParams();
+            if (!params) return;
+            this.startLoading();
+            getDataCenterDeviceDataQuality(params)
+                .then((res) => {
+                    if (res.code === 200) {
+                        this.qualityList = res.data || [];
+                        this.$nextTick(() => this.drawHeatmaps());
+                    }
+                })
+                .finally(() => this.endLoading());
+        },
+        drawHeatmaps() {
+            this.qualityList.forEach((q) => {
+                const el = this.$refs['heatmap-' + q.identifier];
+                const dom = Array.isArray(el) ? el[0] : el;
+                if (!dom) return;
+                const chart = this.$echarts.init(dom);
+                const data = q.heatmapData || [];
+                const maxVal = data.reduce((m, d) => Math.max(m, d[2]), 1);
+                chart.setOption({
+                    tooltip: {
+                        formatter: (p) => `${WEEK_LABELS[p.data[1]]} ${p.data[0]}:00 — ${p.data[2]} 条`,
+                    },
+                    grid: { top: 10, left: 50, right: 10, bottom: 30 },
+                    xAxis: { type: 'category', data: HOUR_LABELS, splitArea: { show: true }, axisLabel: { fontSize: 9 } },
+                    yAxis: { type: 'category', data: WEEK_LABELS, splitArea: { show: true }, axisLabel: { fontSize: 10 } },
+                    visualMap: { min: 0, max: maxVal, show: false, inRange: { color: ['#ebedf0', '#40c463', '#216e39'] } },
+                    series: [{ type: 'heatmap', data, itemStyle: { borderWidth: 1, borderColor: '#fff' } }],
+                });
+            });
+        },
+
+        // ── 直方图 ──
+        fetchHistogram() {
+            const params = this.buildParams();
+            if (!params) return;
+            this.startLoading();
+            getDataCenterDeviceHistogram(params)
+                .then((res) => {
+                    if (res.code === 200) {
+                        this.histogramList = res.data || [];
+                        this.$nextTick(() => this.drawHistograms());
+                    }
+                })
+                .finally(() => this.endLoading());
+        },
+        drawHistograms() {
+            this.histogramList.forEach((h) => {
+                const el = this.$refs['hist-' + h.identifier];
+                const dom = Array.isArray(el) ? el[0] : el;
+                if (!dom) return;
+                const chart = this.$echarts.init(dom);
+
+                if (h.buckets && h.buckets.length > 0) {
+                    // 数值型直方图
+                    chart.setOption({
+                        tooltip: { trigger: 'axis', formatter: (p) => `${p[0].name}<br/>频次：${p[0].value}` },
+                        grid: { top: 10, left: 40, right: 10, bottom: 60, containLabel: true },
+                        xAxis: { type: 'category', data: h.buckets.map((b) => b.label), axisLabel: { rotate: 30, fontSize: 10 } },
+                        yAxis: { type: 'value', name: '频次' },
+                        series: [{ type: 'bar', data: h.buckets.map((b) => b.count), itemStyle: { color: '#409EFF' }, barMaxWidth: 40 }],
+                    });
+                } else if (h.enumDistribution) {
+                    // 枚举/布尔型饼图
+                    const pieData = Object.entries(h.enumDistribution).map(([k, v]) => ({ name: k, value: v }));
+                    chart.setOption({
+                        tooltip: { trigger: 'item' },
+                        legend: { bottom: 0, type: 'scroll' },
+                        series: [{ type: 'pie', radius: ['35%', '65%'], center: ['50%', '45%'], data: pieData, label: { formatter: '{b}\n{d}%', fontSize: 11 } }],
+                    });
+                }
+            });
+        },
+
+        // ── 辅助 ──
+        scoreClass(score) {
+            if (score >= 80) return 'score-good';
+            if (score >= 60) return 'score-warn';
+            return 'score-bad';
+        },
+        formatInterval(seconds) {
+            if (!seconds) return '-';
+            if (seconds < 60) return `${seconds}秒`;
+            if (seconds < 3600) return `${Math.round(seconds / 60)}分钟`;
+            return `${(seconds / 3600).toFixed(1)}小时`;
+        },
+        formatNum(val) {
+            if (val == null) return '-';
+            const num = Number(val);
+            if (isNaN(num)) return '-';
+            const rounded = parseFloat(num.toFixed(6));
+            return rounded;
         },
     },
 };
@@ -596,36 +401,88 @@ export default {
 .data-center-analysis {
     padding: 20px;
 
-    .card-box {
-        padding: 0px;
+    .section-title {
+        font-size: 15px;
+        font-weight: 600;
+        color: #303133;
+        margin-bottom: 12px;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        .section-sub { font-size: 12px; color: #909399; font-weight: normal; margin-left: 6px; }
+    }
 
-        /* 悬停效果，增加交互性 */
-        &:hover {
-            transform: translateY(-5px);
-            box-shadow: 0 8px 12px rgba(0, 0, 0, 0.15);
+    .chart-header { font-size: 14px; font-weight: 600; color: #303133; }
+
+    // 统计卡片
+    .stat-card {
+        .stat-card-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 12px;
+            .stat-count { margin-left: auto; font-size: 12px; color: #909399; }
         }
-
-        .scroll-board-wrap {
-            ::v-deep .header {
-                background-color: #f6f8fa !important;
-                color: #909399;
-                font-weight: bold;
-
-                .header-item {
-                    height: 45px !important;
-                    line-height: 45px !important;
-                }
-            }
-
-            ::v-deep .rows {
-                .row-item {
-                    height: 45px !important;
-                    line-height: 45px !important;
-                    color: #606266;
-                    background-color: #fff !important;
-                }
-            }
+        .metric {
+            border-radius: 6px;
+            padding: 10px;
+            text-align: center;
+            background: #f7f8fa;
+            border-top: 3px solid #ddd;
+            .ml { font-size: 11px; color: #909399; margin-bottom: 5px; }
+            .mv { font-size: 16px; font-weight: 700; color: #303133; word-break: break-all; }
+            .mt { font-size: 10px; color: #c0c4cc; margin-top: 3px; }
+            &.metric-max  { border-top-color: #F56C6C; .mv { color: #F56C6C; } }
+            &.metric-min  { border-top-color: #409EFF; .mv { color: #409EFF; } }
+            &.metric-avg  { border-top-color: #67C23A; .mv { color: #67C23A; } }
+            &.metric-sum  { border-top-color: #9C27B0; .mv { color: #9C27B0; } }
+            &.metric-last { border-top-color: #E6A23C; .mv { color: #E6A23C; } }
+            &.metric-count { border-top-color: #909399; }
         }
     }
+
+    .stat-name { font-size: 14px; font-weight: 600; color: #303133; }
+
+    // 数据质量
+    .quality-header {
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 10px;
+        .quality-score-wrap {
+            margin-left: auto;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+            .quality-score-label { font-size: 12px; color: #909399; }
+            .quality-score {
+                font-size: 22px;
+                font-weight: 700;
+                &.score-good { color: #67C23A; }
+                &.score-warn { color: #E6A23C; }
+                &.score-bad  { color: #F56C6C; }
+            }
+        }
+        .quality-meta {
+            display: flex;
+            gap: 16px;
+            flex-wrap: wrap;
+            width: 100%;
+            .meta-item { font-size: 12px; color: #606266; i { margin-right: 3px; } }
+            .text-warn { color: #E6A23C; }
+            .text-ok   { color: #67C23A; }
+        }
+    }
+
+    .sub-title { font-size: 12px; font-weight: 600; color: #606266; margin-bottom: 8px; }
+
+    .missing-list {
+        max-height: 150px;
+        overflow-y: auto;
+        .missing-item { display: flex; align-items: center; margin-bottom: 6px; font-size: 12px; }
+        .missing-time { color: #606266; }
+        .more-tip { font-size: 11px; color: #909399; }
+    }
+
+    .card-box { &:hover { box-shadow: 0 4px 12px rgba(0,0,0,.1); } }
 }
 </style>