电池数据相关结构体

最新推荐文章于 2024-06-08 21:27:47 发布
最新推荐文章于 2024-06-08 21:27:47 发布
阅读量337 收藏
点赞数
文章标签： android p2p 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chylovecsd/article/details/124957715
版权

 /system/core/healthd/include/healthd/healthd.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

struct healthd_config {
    int periodic_chores_interval_fast;
    int periodic_chores_interval_slow;

    android::String8 batteryStatusPath;
    android::String8 batteryHealthPath;
    android::String8 batteryPresentPath;
    android::String8 batteryCapacityPath;
    android::String8 batteryVoltagePath;
    android::String8 batteryTemperaturePath;
    android::String8 batteryTechnologyPath;
    android::String8 batteryCurrentNowPath;
    android::String8 batteryCurrentAvgPath;
    android::String8 batteryChargeCounterPath;
    android::String8 batteryFullChargePath;
    android::String8 batteryCycleCountPath;
    android::String8 batteryCapacityLevelPath;
    android::String8 batteryChargeTimeToFullNowPath;
    android::String8 batteryFullChargeDesignCapacityUahPath;

    int (*energyCounter)(int64_t *);
    int boot_min_cap;
    bool (*screen_on)(android::BatteryProperties *props);
    std::vector<android::String8> ignorePowerSupplyNames;
};

struct healthd_mode_ops {
    void (*init)(struct healthd_config *config);
    int (*preparetowait)(void);
    void (*heartbeat)(void);
    void (*battery_update)(struct android::BatteryProperties *props);
};

 /frameworks/native/services/batteryservice/include/batteryservice/BatteryService.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

namespace android {
struct BatteryProperties {
    bool chargerAcOnline;
    bool chargerUsbOnline;
    bool chargerWirelessOnline;
    int maxChargingCurrent;
    int maxChargingVoltage;
    int batteryStatus;
    int batteryHealth;
    bool batteryPresent;
    int batteryLevel;
    int batteryVoltage;
    int batteryTemperature;
    int batteryCurrent;
    int batteryCycleCount;
    int batteryFullCharge;
    int batteryChargeCounter;
    String8 batteryTechnology;
};
};

 /hardware/interfaces/health/1.0/default/convert.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include "include/hal_conversion.h"

namespace android {
namespace hardware {
namespace health {
namespace V1_0 {
namespace hal_conversion {
... ...
void convertToHealthInfo(const struct android::BatteryProperties *p,
                                 HealthInfo& info) {
    info.chargerAcOnline        = p->chargerAcOnline;
    info.chargerUsbOnline       = p->chargerUsbOnline;
    info.chargerWirelessOnline  = p->chargerWirelessOnline;
    info.maxChargingCurrent     = p->maxChargingCurrent;
    info.maxChargingVoltage     = p->maxChargingVoltage;
    info.batteryStatus          = static_cast<BatteryStatus>(p->batteryStatus);
    info.batteryHealth          = static_cast<BatteryHealth>(p->batteryHealth);
    info.batteryPresent         = p->batteryPresent;
    info.batteryLevel           = p->batteryLevel;
    info.batteryVoltage         = p->batteryVoltage;
    info.batteryTemperature     = p->batteryTemperature;
    info.batteryCurrent         = p->batteryCurrent;
    info.batteryCycleCount      = p->batteryCycleCount;
    info.batteryFullCharge      = p->batteryFullCharge;
    info.batteryChargeCounter   = p->batteryChargeCounter;
    info.batteryTechnology      = p->batteryTechnology;
}

void convertFromHealthInfo(const HealthInfo& info,
                                   struct android::BatteryProperties *p) {
    p->chargerAcOnline          = info.chargerAcOnline;
    p->chargerUsbOnline         = info.chargerUsbOnline;
    p->chargerWirelessOnline    = info.chargerWirelessOnline;
    p->maxChargingCurrent       = info.maxChargingCurrent;
    p->maxChargingVoltage       = info.maxChargingVoltage;
    p->batteryStatus            = static_cast<int>(info.batteryStatus);
    p->batteryHealth            = static_cast<int>(info.batteryHealth);
    p->batteryPresent           = info.batteryPresent;
    p->batteryLevel             = info.batteryLevel;
    p->batteryVoltage           = info.batteryVoltage;
    p->batteryTemperature       = info.batteryTemperature;
    p->batteryCurrent           = info.batteryCurrent;
    p->batteryCycleCount        = info.batteryCycleCount;
    p->batteryFullCharge        = info.batteryFullCharge;
    p->batteryChargeCounter     = info.batteryChargeCounter;
    p->batteryTechnology        = android::String8(info.batteryTechnology.c_str());
}

} // namespace hal_conversion
} // namespace V1_0
} // namespace health
} // namespace hardware
} // namespace android

 /system/core/healthd/BatteryMonitor.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

namespace android {

#define POWER_SUPPLY_SUBSYSTEM "power_supply"
#define POWER_SUPPLY_SYSFS_PATH "/sys/class/" POWER_SUPPLY_SUBSYSTEM
#define FAKE_BATTERY_CAPACITY 42
#define FAKE_BATTERY_TEMPERATURE 424

BatteryMonitor::PowerSupplyType BatteryMonitor::readPowerSupplyType(const String8& path) {
    static SysfsStringEnumMap<int> supplyTypeMap[] = {
            {"Unknown", ANDROID_POWER_SUPPLY_TYPE_UNKNOWN},  //charger
            {"Battery", ANDROID_POWER_SUPPLY_TYPE_BATTERY},  //battery
            {"UPS", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"Mains", ANDROID_POWER_SUPPLY_TYPE_AC},  //ac
            {"USB", ANDROID_POWER_SUPPLY_TYPE_USB},   //usb
            {"USB_DCP", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"USB_HVDCP", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"USB_CDP", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"USB_ACA", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"USB_C", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"USB_PD", ANDROID_POWER_SUPPLY_TYPE_AC},
            {"USB_PD_DRP", ANDROID_POWER_SUPPLY_TYPE_USB},
            {"Wireless", ANDROID_POWER_SUPPLY_TYPE_WIRELESS},
            {NULL, 0},
    };
    std::string buf;

    if (readFromFile(path, &buf) <= 0)
        return ANDROID_POWER_SUPPLY_TYPE_UNKNOWN;

    auto ret = mapSysfsString(buf.c_str(), supplyTypeMap);
    if (!ret) {
        KLOG_WARNING(LOG_TAG, "Unknown power supply type '%s'\n", buf.c_str());
        *ret = ANDROID_POWER_SUPPLY_TYPE_UNKNOWN;
    }

    return static_cast<BatteryMonitor::PowerSupplyType>(*ret);
}

void BatteryMonitor::init(struct healthd_config *hc) {  //初始化每个property对应的节点路径
    String8 path;                                             //后续BatteryMonitor::getProperty去相应的节点读取数据
    char pval[PROPERTY_VALUE_MAX];

    mHealthdConfig = hc;
    std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(POWER_SUPPLY_SYSFS_PATH), closedir);
    if (dir == NULL) {
        KLOG_ERROR(LOG_TAG, "Could not open %s\n", POWER_SUPPLY_SYSFS_PATH);
    } else {
        struct dirent* entry;

        while ((entry = readdir(dir.get()))) {
            const char* name = entry->d_name;
            std::vector<String8>::iterator itIgnoreName;

            if (!strcmp(name, ".") || !strcmp(name, ".."))
                continue;

            itIgnoreName = find(hc->ignorePowerSupplyNames.begin(),
                                hc->ignorePowerSupplyNames.end(), String8(name));
            if (itIgnoreName != hc->ignorePowerSupplyNames.end())
                continue;

            // Look for "type" file in each subdirectory
            path.clear();
            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, name);  //type/status/health等字符串需要和power_supply_attrs[]
            switch(readPowerSupplyType(path)) {
            case ANDROID_POWER_SUPPLY_TYPE_AC:
            case ANDROID_POWER_SUPPLY_TYPE_USB:
            case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
                path.clear();
                path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
                if (access(path.string(), R_OK) == 0)
                    mChargerNames.add(String8(name));
                break;

            case ANDROID_POWER_SUPPLY_TYPE_BATTERY:
                // Some devices expose the battery status of sub-component like
                // stylus. Such a device-scoped battery info needs to be skipped
                // in BatteryMonitor, which is intended to report the status of
                // the battery supplying the power to the whole system.
                if (isScopedPowerSupply(name)) continue;
                mBatteryDevicePresent = true;

                if (mHealthdConfig->batteryStatusPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
                                      name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryStatusPath = path;
                }

                if (mHealthdConfig->batteryHealthPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
                                      name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryHealthPath = path;
                }

                if (mHealthdConfig->batteryPresentPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
                                      name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryPresentPath = path;
                }

                if (mHealthdConfig->batteryCapacityPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
                                      name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryCapacityPath = path;
                }

                if (mHealthdConfig->batteryVoltagePath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/voltage_now",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0) {
                        mHealthdConfig->batteryVoltagePath = path;
                    }
                }

                if (mHealthdConfig->batteryFullChargePath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/charge_full",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryFullChargePath = path;
                }

                if (mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/current_now",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryCurrentNowPath = path;
                }

                if (mHealthdConfig->batteryCycleCountPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/cycle_count",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryCycleCountPath = path;
                }

                if (mHealthdConfig->batteryCapacityLevelPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/capacity_level", POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0) mHealthdConfig->batteryCapacityLevelPath = path;
                }

                if (mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/time_to_full_now", POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryChargeTimeToFullNowPath = path;
                }

                if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/charge_full_design", POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryFullChargeDesignCapacityUahPath = path;
                }

                if (mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/current_avg",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryCurrentAvgPath = path;
                }

                if (mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/charge_counter",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryChargeCounterPath = path;
                }

                if (mHealthdConfig->batteryTemperaturePath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
                                      name);
                    if (access(path, R_OK) == 0) {
                        mHealthdConfig->batteryTemperaturePath = path;
                    }
                }

                if (mHealthdConfig->batteryTechnologyPath.isEmpty()) {
                    path.clear();
                    path.appendFormat("%s/%s/technology",
                                      POWER_SUPPLY_SYSFS_PATH, name);
                    if (access(path, R_OK) == 0)
                        mHealthdConfig->batteryTechnologyPath = path;
                }

                break;

            case ANDROID_POWER_SUPPLY_TYPE_UNKNOWN:
                break;
            }
        }
    }

    // Typically the case for devices which do not have a battery and
    // and are always plugged into AC mains.
    if (!mBatteryDevicePresent) {
        KLOG_WARNING(LOG_TAG, "No battery devices found\n");
        hc->periodic_chores_interval_fast = -1;
        hc->periodic_chores_interval_slow = -1;
    } else {
        if (mHealthdConfig->batteryStatusPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryStatusPath not found\n");
        if (mHealthdConfig->batteryHealthPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryHealthPath not found\n");
        if (mHealthdConfig->batteryPresentPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryPresentPath not found\n");
        if (mHealthdConfig->batteryCapacityPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryCapacityPath not found\n");
        if (mHealthdConfig->batteryVoltagePath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryVoltagePath not found\n");
        if (mHealthdConfig->batteryTemperaturePath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n");
        if (mHealthdConfig->batteryTechnologyPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n");
        if (mHealthdConfig->batteryCurrentNowPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryCurrentNowPath not found\n");
        if (mHealthdConfig->batteryFullChargePath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryFullChargePath not found\n");
        if (mHealthdConfig->batteryCycleCountPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "BatteryCycleCountPath not found\n");
        if (mHealthdConfig->batteryCapacityLevelPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "batteryCapacityLevelPath not found\n");
        if (mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "batteryChargeTimeToFullNowPath. not found\n");
        if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty())
            KLOG_WARNING(LOG_TAG, "batteryFullChargeDesignCapacityUahPath. not found\n");
    }

    if (property_get("ro.boot.fake_battery", pval, NULL) > 0
                                               && strtol(pval, NULL, 10) != 0) {
        mBatteryFixedCapacity = FAKE_BATTERY_CAPACITY;  //如果这里赋值了，那BatteryMonitor::updateValues就会使用这个值
        mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE;  //如果这里赋值了，那BatteryMonitor::updateValues就会使用这个值
    }
}

}; // n

 /system/core/healthd/BatteryMonitor.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
    status_t ret = BAD_VALUE;
    std::string buf;

    val->valueInt64 = LONG_MIN;

    switch(id) {
    case BATTERY_PROP_CHARGE_COUNTER:
        if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
            val->valueInt64 =
                getIntField(mHealthdConfig->batteryChargeCounterPath);
            ret = OK;
        } else {
            ret = NAME_NOT_FOUND;
        }
        break;

    case BATTERY_PROP_CURRENT_NOW:
        if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
            val->valueInt64 =
                getIntField(mHealthdConfig->batteryCurrentNowPath);
            ret = OK;
        } else {
            ret = NAME_NOT_FOUND;
        }
        break;

    case BATTERY_PROP_CURRENT_AVG:
        if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
            val->valueInt64 =
                getIntField(mHealthdConfig->batteryCurrentAvgPath);
            ret = OK;
        } else {
            ret = NAME_NOT_FOUND;
        }
        break;

    case BATTERY_PROP_CAPACITY:
        if (!mHealthdConfig->batteryCapacityPath.isEmpty()) {
            val->valueInt64 =
                getIntField(mHealthdConfig->batteryCapacityPath);
            ret = OK;
        } else {
            ret = NAME_NOT_FOUND;
        }
        break;

    case BATTERY_PROP_ENERGY_COUNTER:
        if (mHealthdConfig->energyCounter) {
            ret = mHealthdConfig->energyCounter(&val->valueInt64);
        } else {
            ret = NAME_NOT_FOUND;
        }
        break;

    case BATTERY_PROP_BATTERY_STATUS:
        val->valueInt64 = getChargeStatus();
        ret = OK;
        break;

    default:
        break;
    }

    return ret;
}

=========================================================================

struct HealthInfo和struct BatteryProperties的定义如下：

后续可通过convertToHealthInfo()/convertFromHealthInfo()进行数据交换：

1.getProperty()获取数据保存在struct HealthInfo

2.convertFromHealthInfo()将数据拷贝到struct BatteryProperties

3.healthd_mode_ops->battery_update(&props);上报电池数据

 /frameworks/native/services/batteryservice/include/batteryservice/BatteryService.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

namespace android {

#include "BatteryServiceConstants.h"

// must be kept in sync with definitions in
// frameworks/base/core/java/android/os/BatteryManager.java
enum {
    BATTERY_PROP_CHARGE_COUNTER = 1, // equals BATTERY_PROPERTY_CHARGE_COUNTER
    BATTERY_PROP_CURRENT_NOW = 2, // equals BATTERY_PROPERTY_CURRENT_NOW
    BATTERY_PROP_CURRENT_AVG = 3, // equals BATTERY_PROPERTY_CURRENT_AVERAGE
    BATTERY_PROP_CAPACITY = 4, // equals BATTERY_PROPERTY_CAPACITY
    BATTERY_PROP_ENERGY_COUNTER = 5, // equals BATTERY_PROPERTY_ENERGY_COUNTER
    BATTERY_PROP_BATTERY_STATUS = 6, // equals BATTERY_PROPERTY_BATTERY_STATUS
};

struct BatteryProperties {
    bool chargerAcOnline;
    bool chargerUsbOnline;
    bool chargerWirelessOnline;
    int maxChargingCurrent;
    int maxChargingVoltage;
    int batteryStatus;
    int batteryHealth;
    bool batteryPresent;
    int batteryLevel;
    int batteryVoltage;
    int batteryTemperature;
    int batteryCurrent;
    int batteryCycleCount;
    int batteryFullCharge;
    int batteryChargeCounter;
    String8 batteryTechnology;
};

struct BatteryProperty {
    int64_t valueInt64;
};

}; // namespace android

 /hardware/interfaces/health/1.0/types.hal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

struct HealthInfo {
    /** AC charger state - 'true' if online */
    bool chargerAcOnline;

    /** USB charger state - 'true' if online */
    bool chargerUsbOnline;

    /** Wireless charger state - 'true' if online */
    bool chargerWirelessOnline;

    /** Maximum charging current supported by charger in uA */
    int32_t maxChargingCurrent;

    /** Maximum charging voltage supported by charger in uV */
    int32_t maxChargingVoltage;

    BatteryStatus batteryStatus;

    BatteryHealth batteryHealth;

    /** 'true' if battery is present */
    bool batteryPresent;

    /** Remaining battery capacity in percent */
    int32_t batteryLevel;

    /**
     * Instantaneous battery voltage in millivolts (mV).
     *
     * Historically, the unit of this field is microvolts (uV), but all
     * clients and implementations uses millivolts in practice, making it
     * the de-facto standard.
     */
    int32_t batteryVoltage;

    /** Instantaneous battery temperature in tenths of degree celcius */
    int32_t batteryTemperature;

    /** Instantaneous battery current in uA */
    int32_t batteryCurrent;

    /** Battery charge cycle count */
    int32_t batteryCycleCount;

    /** Battery charge value when it is considered to be "full" in uA-h */
    int32_t batteryFullCharge;

    /** Instantaneous battery capacity in uA-h */
    int32_t batteryChargeCounter;

    /** Battery technology, e.g. "Li-ion, Li-Poly" etc. */
    string batteryTechnology;
};

0_0i_i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MTK 关机充电时充电IC正常，电池正常充电，但是充电动画一直显示0%
H_Xjun的博客
07-28 1893
android s0 MTK 关机充电时充电IC正常，电池正常充电，但是充电动画一直显示0%
android 电池（三）：android电池系统
CLK
03-23 4万+
关键词：android电池系统电池系统架构 uevent power_supply驱动 平台信息: 内核：linux2.6/linux3.0 系统：android/android4.0  平台：S5PV310(samsungexynos4210) 、samsung exynos4412 作者：xubin341719(欢迎转载，请注明作者) andro
Android 11 低电量自动关机失效
最新发布
ansondroider的博客
06-08 811
基于RK3568 Android 11 系统开发过程中, 移植了电源和电池相关的驱动后, 测试发现低电自动关机的功能失效了, 基于源码SDK排查问题过程记录
Linux power_supply子系统
南大侠的博客
02-16 2582
Linux power_supply子系统 1.概念 power supply子系统的引入是由于设备中通常存在多个psy设备，不同的psy设备作用不同，比如电池、DC充电和usb充电等。驱动使用power suply框架 把不同的psy设备都注册成单一节点，当属性变化时，通过uevent的方式通知应用 2.Power Supply Framework 架构 内核抽象power supply子系统为驱动提供了统一的架构，其中功能包括：抽象PSY设备的共性，向用户空间提供统一的API，为底层PSY驱动的编写，提
android4.4 healthd深入分析
Android framework
07-28 983
android4.4 healthd深入分析
bdc.zip_电池放电
09-23
3. **xitoa.h** 和 **xitoa.S**：这两个文件可能是一个将十进制数转换为ASCII字符串的库，用于将电池数据格式化为可读的字符流，便于通过UART发送。 4. **integer.h**：可能包含了一些处理整数操作的辅助函数，例如...
Android实现电池管理系统
08-28
BatteryService是电池服务的核心，负责监听底层上报的电池事件，并将最新的电池数据通过广播的形式上报给系统。系统一旦接收到新的电池信息，将根据这些信息更新电池显示状态和剩余电量等。 ActivityManagerService...
易语言取笔记本电脑电池信息
07-16
其中，`SystemPowerStatus`结构体包含了电池的相关信息，如电池充电状态、剩余电量百分比、电池警告状态等。在易语言中定义这个结构体如下： ```易语言 .结构体 SystemPowerStatus .整数型 ACLineStatus ; 交流...
易语言源码易语言取笔记本电脑电池信息源码.rar
02-18
通过分析这段源码，我们可以学习如何在易语言中与硬件进行交互，特别是获取电池状态相关的数据。 首先，我们需要了解易语言的基本结构和语法规则。易语言的核心思想是将常用的操作用简单的词汇表示，比如“取”、...
易语言源码易语言取笔记本电池状态源码.rar
02-18
调用API后，你需要解析`SYSTEM_POWER_STATUS`结构中的数据，如`BatteryLifePercent`字段表示电池剩余百分比，`ACLineStatus`字段表示当前是否连接到交流电源。根据这些信息，你可以更新程序的界面，展示电池的状态...
展锐USB充电图标更新流程
weixin_42265250的博客
07-31 506
power_supply 目录下online节点是用于判断是否插入battery、ac(外部电源) 和USB 的节点，目录在sys/class/power_supply/battery(ac、usb)/online，主要用于在StatusBar 上显示充电的闪电图标。这篇文章将梳理USB 充电电池状态从kernel 上发到FW层的流程
android充电架构的分析
Liu Boqiang 博客
12-29 1403
前言 目前android设备越来越多，对于快速充电和长时间待机的需求就不言而喻。对应于此的就是各大手机厂商不断突破大功率充电新闻频繁的出现。在个人目前遇到的快充方案中，基本上在大的架构下属于同一种类型。故分析记录下来。 标题 充电简单粗暴点来说就是把电流灌到电池里面去。那么最简单的方法就是直接拿一个电源接在电池的正负极。只要电源电压高于电池电压就可以把电流灌进去。就如同直接打开水龙头开关接水一样。 但是这样会存在很多问题。例如：电池此时的电压很小，电源电压很高，一怼上电池上的电流就会变得非常大，很可能烧坏电
Android获取电池电量的三种方法
XiaYiZhanQiHang的博客
02-19 2万+
方法一：注册广播 这个方法网上一搜一大堆，我也贴出部分代码 IntentFilter filter2 = new IntentFilter(); filter2.addAction(Intent.ACTION_BATTERY_CHANGED); registerReceiver(filter2,receiver); 接收到广播后，用getIntExtra("level")和getIntE
porting MPTCP to LineageOS-14.1-kiwi - 内核包含MPTCP--cat-dev-kmsg.txt
张同光 (Tongguang Zhang)：Hello everyone !
04-12 7033
porting MPTCP to LineageOS-14.1-kiwi - 内核包含MPTCP--cat-dev-kmsg.txt
porting MPTCP to LineageOS-14.1-kiwi - 内核不包含MPTCP--cat-dev-kmsg.txt
张同光 (Tongguang Zhang)：Hello everyone !
04-12 6097
porting MPTCP to LineageOS-14.1-kiwi - 内核不包含MPTCP--cat-dev-kmsg.txt
Map转为String
热门推荐
斜阳雨陌
09-19 4万+
Map转为String 最近在做redis缓存时，需要将一个Map的对象转换为String对象存入redis，用的时候需从redis中取出来后并转为Map对象。 之前的做法直接就是Map对象的toString()存入redis,后面取出是就是用再转换为Map. String转换为：JSONObject jsonobject = JSONObject.fromObject(st
android 9.0 getIntProperty获取系统当前电量流程分析(二)
liangguangyuan的博客
10-20 493
接着看上一篇android 9.0 getIntProperty获取系统当前电量流程分析(一)，分析getCapacity在HIDL中的实现 service.getCapacity((int result, int value) -> { outResult.value = result; ...
在驱动模块初始化函数中实现设备节点的自动创建
华清远见 | 程序员的学习天堂
08-26 1113
作者：杨硕，华清远见嵌入式学院讲师。我们在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了udev。内核中定义了struct class结构体，顾名思义，一个struct class结构体类型
MTK电池算法与误差分析
此外，插入或拔出充电器也会触发中断，导致电池数据的即时更新。所有与电池充电相关的数据都存储在Kernel层的`power`结构体中，以供系统其他组件访问。 MTK电池算法涉及从硬件采样到软件估算的全过程，通过对72/82...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值