RTC(电池电量保存)

最新推荐文章于 2023-03-29 15:13:51 发布
最新推荐文章于 2023-03-29 15:13:51 发布
阅读量673 收藏 1
点赞数
文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chylovecsd/article/details/124957756
版权

int bat_thread_kthread(void *x)

 ->BAT_thread();

  ->mt_battery_update_status();

   ->usb_update(&usb_main);

   ->ac_update(&ac_main);

   ->wireless_update(&wireless_main);

   ->battery_update(&battery_main);

    ->set_rtc_spare_fg_value(BMT_status.UI_SOC);

     ->hal_rtc_set_spare_register(RTC_FGSOC, val);

 /kernel-4.19-lc/drivers/misc/mediatek/include/mt-plat/mtk_rtc_hal_common.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

enum rtc_spare_enum {
    RTC_FGSOC = 0,
    RTC_ANDROID,
    RTC_FAC_RESET,
    RTC_BYPASS_PWR,
    RTC_PWRON_TIME,
    RTC_FAST_BOOT,
    RTC_KPOC,
    RTC_DEBUG,
    RTC_PWRON_AL,
    RTC_UART,
    RTC_AUTOBOOT,
    RTC_PWRON_LOGO,
    RTC_32K_LESS,
    RTC_LP_DET,
    RTC_FG_INIT,
    RTC_SPAR_NUM
};

enum rtc_reg_set {
    RTC_REG,
    RTC_MASK,
    RTC_SHIFT
};

 /kernel-4.19-lc/drivers/misc/mediatek/rtc/mtk_rtc_common.c

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

int get_rtc_spare_fg_value(void)
{
    /* RTC_AL_HOU bit8~14 */
    u16 temp;
    unsigned long flags;

    spin_lock_irqsave(&rtc_lock, flags);
    temp = hal_rtc_get_spare_register(RTC_FGSOC);
    spin_unlock_irqrestore(&rtc_lock, flags);

    return temp;
}

int set_rtc_spare_fg_value(int val)
{
    /* RTC_AL_HOU bit8~14 */
    unsigned long flags;

#ifdef CONFIG_MTK_GAUGE_VERSION
#if (CONFIG_MTK_GAUGE_VERSION != 30)
    if (val > 100)
        return 1;
#endif
#endif

    spin_lock_irqsave(&rtc_lock, flags);
    hal_rtc_set_spare_register(RTC_FGSOC, val);
    spin_unlock_irqrestore(&rtc_lock, flags);

    return 0;
}

 /kernel-4.19-lc/drivers/misc/mediatek/rtc/mt6350/mt_rtc_hw.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
40

#define RTC_BASE             (0x8000)
/*
 * RTC_NEW_SPARE0: RTC_AL_HOU bit0~4
 *        bit 8 ~ 14 : Fuel Gauge
 *     bit 15     : reserved bits
 */
#define RTC_AL_HOU            (RTC_BASE + 0x001c)
/*
 * RTC_PDN1:
 *     bit 0 - 3  : Android bits
 *     bit 4 - 5  : Recovery bits (0x10: factory data reset)
 *     bit 6      : Bypass PWRKEY bit
 *     bit 7      : Power-On Time bit
 *     bit 8      : RTC_GPIO_USER_WIFI bit
 *     bit 9      : RTC_GPIO_USER_GPS bit
 *     bit 10     : RTC_GPIO_USER_BT bit
 *     bit 11     : RTC_GPIO_USER_FM bit
 *     bit 12     : RTC_GPIO_USER_PMIC bit
 *     bit 13     : Fast Boot
 *     bit 14      : Kernel Power Off Charging
 *     bit 15     : Debug bit
 */
#define RTC_PDN1                 (RTC_BASE + 0x002c)
/*
 * RTC_PDN2:
 *     bit 0 - 3 : MTH in power-on time
 *     bit 4     : Power-On Alarm bit
 *     bit 5 - 6 : UART bits
 *     bit 7     : reserved bit
 *     bit 8 - 14: YEA in power-on time
 *     bit 15    : Power-On Logo bit
 */
#define RTC_PDN2            (RTC_BASE + 0x002e)
/*
 * RTC_SPAR0:
 *     bit 0 - 5 : SEC in power-on time
 *     bit 6      : 32K less bit. True:with 32K, False:Without 32K
 *     bit 7 - 15: reserved bits
 */
#define RTC_SPAR0               (RTC_BASE + 0x0030)

 /kernel-4.19-lc/drivers/misc/mediatek/rtc/mt6350/mtk_rtc_hal.c

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

u16 rtc_spare_reg[RTC_SPAR_NUM][3] = {
    {RTC_AL_HOU, 0x7f, 8},
    {RTC_PDN1, 0xf, 0},
    {RTC_PDN1, 0x3, 4},
    {RTC_PDN1, 0x1, 6},
    {RTC_PDN1, 0x1, 7},
    {RTC_PDN1, 0x1, 13},
    {RTC_PDN1, 0x1, 14},
    {RTC_PDN1, 0x1, 15},
    {RTC_PDN2, 0x1, 4},
    {RTC_PDN2, 0x3, 5},
    {RTC_PDN2, 0x1, 7},
    {RTC_PDN2, 0x1, 15},
    {RTC_SPAR0, 0x1, 6},
    {RTC_SPAR0, 0x1, 7}
};

 /kernel-4.19-lc/drivers/misc/mediatek/rtc/mtk_rtc_hal_common.c

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

void hal_rtc_set_spare_register(enum rtc_spare_enum cmd, u16 val)
{
    u16 tmp_val;

    if (cmd >= 0 && cmd < RTC_SPAR_NUM) {
        tmp_val =
            rtc_read(rtc_spare_reg[cmd][RTC_REG]) & ~(rtc_spare_reg[cmd][RTC_MASK] <<
                                  rtc_spare_reg[cmd][RTC_SHIFT]);
        rtc_write(rtc_spare_reg[cmd][RTC_REG],
              tmp_val | ((val & rtc_spare_reg[cmd][RTC_MASK]) <<
                     rtc_spare_reg[cmd][RTC_SHIFT]));
        rtc_write_trigger();
    }
}

u16 hal_rtc_get_spare_register(enum rtc_spare_enum cmd)
{
    u16 tmp_val;

    if (cmd >= 0 && cmd < RTC_SPAR_NUM) {
        hal_rtc_xinfo("rtc_spare_reg[%d] = {%d, %d, %d}\n", cmd,
                  rtc_spare_reg[cmd][RTC_REG], rtc_spare_reg[cmd][RTC_MASK],
                  rtc_spare_reg[cmd][RTC_SHIFT]);
        tmp_val = rtc_read(rtc_spare_reg[cmd][RTC_REG]);
        tmp_val = (tmp_val >> rtc_spare_reg[cmd][RTC_SHIFT]) & rtc_spare_reg[cmd][RTC_MASK];
        return tmp_val;
    }
    return 0;
}

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

static void nl_data_handler(struct sk_buff *skb)

 ->bmd_ctrl_cmd_from_user(data, fgd_ret_msg);  //void bmd_ctrl_cmd_from_user(void *nl_data, struct fgd_nl_msg_t *ret_msg)

  ->case FG_DAEMON_CMD_GET_RTC_UI_SOC:

   ->gauge_dev_get_rtc_ui_soc(gm.gdev, &rtc_ui_soc);

    ->gauge_dev->ops->gauge_get_rtc_ui_soc(gauge_dev, ui_soc);

     ->spare3_reg = get_rtc_spare_fg_value();

     ->*ui_soc = (spare3_reg & 0x7f);  //取低7位

  ->case FG_DAEMON_CMD_SET_RTC_UI_SOC:

   ->gauge_dev_set_rtc_ui_soc(gm.gdev, rtc_ui_soc);

    ->gauge_dev->ops->gauge_set_rtc_ui_soc(gauge_dev, ui_soc); 

     ->spare3_reg = get_rtc_spare_fg_value()

     ->new_spare3_reg = (spare3_reg & 0x80) + rtc_ui_soc;  //将低7位清零

     ->set_rtc_spare_fg_value(new_spare3_reg)

 ->nl_send_to_user(pid, seq, fgd_ret_msg);

 /kernel-4.14/arch/arm64/boot/dts/mediatek/mt8168.dtsi

1
2
3
4
5
6
7
8
9
10
11
12
13

/ {
    model = "MT8168";
    compatible = "mediatek,mt8168";
    interrupt-parent = <&sysirq>;
    #address-cells = <2>;
    #size-cells = <2>;

    mt6357_gauge {
        compatible = "mediatek,mt6357_gauge";
        gauge_name = "gauge";
        alias_name = "MT6357";
    };
};

 /kernel-4.14/drivers/misc/mediatek/pmic/mt6357/v1/mt6357_gauge.c

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

static struct gauge_ops mt6357_gauge_ops = {
    ... ...
    .gauge_set_rtc_ui_soc = fgauge_set_rtc_ui_soc,
    .gauge_get_rtc_ui_soc = fgauge_get_rtc_ui_soc,
};

static int mt6357_gauge_probe(struct platform_device *pdev)
{
    int ret = 0;
    struct mt6357_gauge *info;

    bm_debug("%s: starts\n", __func__);

    info = devm_kzalloc(
        &pdev->dev,
        sizeof(struct mt6357_gauge),
        GFP_KERNEL);
    if (!info)
        return -ENOMEM;

    mt6357_parse_dt(info, &pdev->dev);
    platform_set_drvdata(pdev, info);

    /* Register charger device */
    info->gauge_dev = gauge_device_register(info->gauge_dev_name,
        &pdev->dev, info, &mt6357_gauge_ops, &info->gauge_prop);
    if (IS_ERR_OR_NULL(info->gauge_dev)) {
        ret = PTR_ERR(info->gauge_dev);
        goto err_register_gauge_dev;
    }

    return 0;
err_register_gauge_dev:
    devm_kfree(&pdev->dev, info);
    return ret;

}

static const struct of_device_id mt6357_gauge_of_match[] = {
    {.compatible = "mediatek,mt6357_gauge",},
    {},
};

MODULE_DEVICE_TABLE(of, mt6357_gauge_of_match);

static struct platform_driver mt6357_gauge_driver = {
    .probe = mt6357_gauge_probe,
    .remove = mt6357_gauge_remove,
    .shutdown = mt6357_gauge_shutdown,
    .driver = {
           .name = "mt6357_gauge",
           .of_match_table = mt6357_gauge_of_match,
           },
};

static int __init mt6357_gauge_init(void)
{
    return platform_driver_register(&mt6357_gauge_driver);
}
device_initcall(mt6357_gauge_init);

static void __exit mt6357_gauge_exit(void)
{
    platform_driver_unregister(&mt6357_gauge_driver);
}
module_exit(mt6357_gauge_exit);

 /kernel-4.14/drivers/misc/mediatek/pmic/mt6357/v1/mt6357_gauge.c

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

static int fgauge_set_rtc_ui_soc(struct gauge_device *gauge_dev, int rtc_ui_soc)
{
    int spare3_reg = get_rtc_spare_fg_value();
    int spare3_reg_valid;
    int new_spare3_reg;

    spare3_reg_valid = (spare3_reg & 0x80);
    new_spare3_reg = spare3_reg_valid + rtc_ui_soc;

    /* set spare3 0x7f */
    set_rtc_spare_fg_value(new_spare3_reg);

    bm_notice("[fg_set_rtc_ui_soc] rtc_ui_soc %d spare3_reg 0x%x new_spare3_reg 0x%x\n",
        rtc_ui_soc, spare3_reg, new_spare3_reg);

    return 0;
}

static int fgauge_get_rtc_ui_soc(struct gauge_device *gauge_dev, int *ui_soc)
{
    int spare3_reg = get_rtc_spare_fg_value();
    int rtc_ui_soc;

    rtc_ui_soc = (spare3_reg & 0x7f);

    *ui_soc = rtc_ui_soc;
    bm_notice("[%s] rtc_ui_soc %d spare3_reg 0x%x\n",
        __func__, rtc_ui_soc, spare3_reg);

    return 0;
}

 /kernel-4.14/drivers/mfd/mt6358-misc.c

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

#define RTC_AL_HOU              0x24
#define RTC_AL_MTH              0x2a
#define RTC_PDN1                0x34
#define RTC_PDN2                0x36
#define RTC_SPAR0               0x38
#define RTC_SPAR1               0x3a
#define RTC_WRTGR                                0x42

enum rtc_spare_enum {
    RTC_FGSOC = 0,
    RTC_ANDROID,
    RTC_FAC_RESET,
    RTC_BYPASS_PWR,
    RTC_PWRON_TIME,
    RTC_FAST_BOOT,
    RTC_KPOC,
    RTC_DEBUG,
    RTC_PWRON_AL,
    RTC_UART,
    RTC_AUTOBOOT,
    RTC_PWRON_LOGO,
    RTC_32K_LESS,
    RTC_LP_DET,
    RTC_FG_INIT,
    RTC_SPAR_NUM
};

enum rtc_reg_set {
    RTC_REG,
    RTC_MASK,
    RTC_SHIFT
};

u16 rtc_spare_reg[RTC_SPAR_NUM][3] = {  //和rtc_spare_enum一一对应
    {RTC_AL_MTH, 0xff, 8},
    {RTC_PDN1, 0xf, 0},
    {RTC_PDN1, 0x3, 4},
    {RTC_PDN1, 0x1, 6},
    {RTC_PDN1, 0x1, 7},
    {RTC_PDN1, 0x1, 13},
    {RTC_PDN1, 0x1, 14},
    {RTC_PDN1, 0x1, 15},
    {RTC_PDN2, 0x1, 4},
    {RTC_PDN2, 0x3, 5},
    {RTC_PDN2, 0x1, 7},
    {RTC_PDN2, 0x1, 15},
    {RTC_SPAR0, 0x1, 6},
    {RTC_SPAR0, 0x1, 7},
    {RTC_AL_HOU, 0xff, 8}
};

 /kernel-4.14/drivers/mfd/mt6358-misc.c

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

int get_rtc_spare_fg_value(void)
{
    /* RTC_AL_HOU bit8~14 */
    u16 temp;
    unsigned long flags;

    spin_lock_irqsave(&rtc_misc->lock, flags);
    temp = mtk_rtc_get_spare_register(RTC_FGSOC);
    spin_unlock_irqrestore(&rtc_misc->lock, flags);

    return temp;
}

int set_rtc_spare_fg_value(int val)
{
    /* RTC_AL_HOU bit8~14 */
    unsigned long flags;

    spin_lock_irqsave(&rtc_misc->lock, flags);
    mtk_rtc_set_spare_register(RTC_FGSOC, val);
    spin_unlock_irqrestore(&rtc_misc->lock, flags);

    return 0;
}

 /kernel-4.14/drivers/mfd/mt6358-misc.c

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

static int mtk_rtc_get_spare_register(enum rtc_spare_enum cmd)
{
    unsigned int tmp_val = 0;
    int ret = -EINVAL;

    if (cmd >= 0 && cmd < RTC_SPAR_NUM) {

        ret = rtc_field_read(rtc_spare_reg[cmd][RTC_REG],
                rtc_spare_reg[cmd][RTC_MASK]
                    << rtc_spare_reg[cmd][RTC_SHIFT],
                rtc_spare_reg[cmd][RTC_SHIFT],
                &tmp_val);

        if (ret < 0)
            goto exit;

        pr_notice("%s: cmd[%d], get rg[0x%x, 0x%x , %d] = 0x%x\n",
                  __func__, cmd,
                  rtc_spare_reg[cmd][RTC_REG],
                  rtc_spare_reg[cmd][RTC_MASK],
                  rtc_spare_reg[cmd][RTC_SHIFT], tmp_val);

        return tmp_val;
    }

exit:
    return ret;
}

static void mtk_rtc_set_spare_register(enum rtc_spare_enum cmd, u16 val)
{
    u32 tmp_val = 0;
    int ret;

    if (cmd >= 0 && cmd < RTC_SPAR_NUM) {

        pr_notice("%s: cmd[%d], set rg[0x%x, 0x%x , %d] = 0x%x\n",
                  __func__, cmd,
                  rtc_spare_reg[cmd][RTC_REG],
                  rtc_spare_reg[cmd][RTC_MASK],
                  rtc_spare_reg[cmd][RTC_SHIFT], val);

        tmp_val = ((val & rtc_spare_reg[cmd][RTC_MASK])
                    << rtc_spare_reg[cmd][RTC_SHIFT]);
        ret = rtc_update_bits(rtc_spare_reg[cmd][RTC_REG],
                rtc_spare_reg[cmd][RTC_MASK]
                    << rtc_spare_reg[cmd][RTC_SHIFT],
                tmp_val);
        if (ret < 0)
            goto exit;
        ret = rtc_write_trigger();
        if (ret < 0)
            goto exit;
    }
    return;
exit:
    pr_err("%s error\n", __func__);
}

 /kernel-4.14/drivers/mfd/mt6358-misc.c

1
2
3
4
5
6
7
8
9
10

static int rtc_write_trigger(void)
{
    int ret;

    ret = rtc_write(RTC_WRTGR, 1);
    if (ret < 0)
        return ret;

    return rtc_busy_wait();
}

0_0i_i
关注
案例分析-RTC电源上的串联电阻多少合适
whm128的博客
08-10 313
主要介绍分享下，RTC设计的一知识分析，内容为网络知识整理，现在几乎所有的电子产品都带RTC功能，因此RTC电池的寿命肯定是越长越好。
MTK Android 之MT6577驱动笔记
热门推荐
caobaokang的专栏
07-19 3万+
转载请注明出处：http://blog.csdn.net/cbk861110/article/details/9385439 1. LCD 1.1怎样新建一个LCD驱动 LCD模组主要包括LCD显示屏和驱动IC。比如LF040DNYB16a模组的驱动IC型号为NT35510。要在MT577平台上新建这个lcd的驱动，步骤如下： A.新建文件夹nt35510： \medi...
RTC.rar_RTC_STM32 RTC_STM32 RTC battery_stm32 rtc
09-21
STM32是以Cortex-M3为核的处理器，该例程介绍STM32下如何对实时钟RTC进行操作。RTC可保存时间，由电池供电。
干货｜案例分享——RTC电池寿命探讨，才半年就要换电池？
最新发布
m0_38012497的博客
03-29 790
转载自 干货｜案例分享——RTC电池寿命探讨，才半年就要换电池？_腾讯新闻 (qq.com) 干货｜案例分享——RTC电池寿命探讨，才半年就要换电池？_腾讯新闻 (qq.com)
RTC电池供电时二极管选择注意
学海无涯的专栏
02-02 6617
RTC电池供电时二极管选择注意 MCU的VBAT引脚 做电池和系统供电同时供电的RTC设计时遇到的问题 在一些用到RTC的场合，常会遇到这样的供电电路。这个电路从原理上看是没问题的，但是要注意VBAT与V3.3V之间的二极管的选择。 注意最好不要用肖特基二极管，为什么呢？肖特基二极管的反向电流一般都是mA级的.(表示怀疑？应该是uA级) 问题：在系统不工作的时候，RTC电池就会通过二极管将电供到3.3V的系统中，一般RTC的电池也就是几十个mAh，很快就用光了。什么原因？ 反向电..
【纯技术】MTK Fuel Gauge算法分析
背后的菜鸟
12-22 6242
Battery 架构简析 MTK 平台 Battery 软件架构基本如上图所示。 具体过程: 硬件 ADC 读取 Battery 的各路信息:包括温度,电压等。 MTK 开发的电量算法分析得到的数据。 Kernel 层将电量信息通过写文件节点的方式更新,并通过 UEVENT 通知上层。 上层 Service 开启 UEVENT LISTENER,监听到 UEVENT 后,读取
充电问题解决总结
wangyongh的博客
04-25 2794
充电问题解决总结
RTC.rar_RTC_pxa270
09-20
RTC在PXA270中的实现包括一个内部电池供电的时钟电路，即使主电源被切断，也能保持运行。 RTC驱动程序是操作系统与硬件RTC之间的桥梁，负责初始化、读取和设置时间，以及处理中断。在Linux内核中，RTC驱动通常作为...
Rtc.rar_RTC 实时时钟_lpc2119_lpc2119时钟
09-22
7. **错误处理**：在RTC操作中可能出现的错误包括时钟初始化失败、电池电量不足导致的时间丢失等。开发者应为这些情况设计适当的错误处理机制。 综上所述，"Rtc.rar"提供的LPC2119 RTC实时时钟程序涵盖了嵌入式系统...
STM32RTC实时时钟
01-16
7. **掉电检测**：可以使用STM32的PWR（Power）接口的VBAT引脚检测电池电压，当电池电量过低时，可以提前采取措施，如更换电池或提醒用户。 8. **RTC同步**：在系统启动时，需要检查RTC的状态，如果发现时间丢失，...
海思的rtc说明
whitefish520的博客
07-23 9657
文章目录前言使用设置获取时间设置获取闹钟时间读取、设置 RTC 内部寄存器复位 RTC 模块固定分频模式分频系数微调设置打开、关闭电池电量监测功能解决linux系统时间问题设置时区利用NTP获取网络时间 前言 关于海思的RTC，官方给出了一份文档 RTC 应用指南.pdf 里面讲到需要编译对应的驱动和应用程序，代码地址位于 Hi3531DV100_SDK_V1.0.5.0\drv\rtc 注意，如果你的arm-linux-gcc这个没有指向对应的工具链的话，就要先修改makefile，指定一下CC的
电量计-gauge驱动android
08-23
电量计-gauge驱动android 包含max17040和bq27410驱动code
mt6737电池状态监测
Android开发
05-30 3389
　　　这里分析下mt6735平台下的电池驱动，使用的bq24296芯片(开关模式的充电方式)。kernel-3.18/drivers/power/mediatek/battery_common.cstatic int battery_probe(struct platform_device *dev) { struct class_device *class_dev = NULL; int r...
MTK 充电知识
cktrobin的博客
01-14 4135
相关概念 懒的排版了，直接上图 相关文件关系 再来一发 杂项，电池温度检测原理图 发 充电流程 图样图森破 核心函数特写 /* 概念: ZCV：开路电压 OCV: 开路电压 VC：闭路电压 CAR：库伦计 DOD: 放电深度，100-DOD 即电容容量 Cmax/Qmax: 电池容量 相关文件关系: Battery_common.c (s:\i841\mediatek\k...
安卓电池管理
uunubt的专栏
10-09 1462
android系统电池部分的驱动程序，继承了传统linux系统下的Power Supply驱动程序架构，Battery驱动程序通过Power Supply驱动程序生成相应的sys文件系统，从而向用户空间提供电池各种属性的接口。Linux标准的 Power Supply驱动程序所使用的文件系统路径为:/sys/class/power_supply ,其中的每个子目录表示一种能源供应设备。
reboot recovery的执行过程及syscall系统调用分析
kinggate518的博客
06-29 2799
要进入recovery模式，可以在java层调用函数，也可以执行shell命令“reboot recovery”进入。 这里分析“reboot recovery”流程。 （由于水平有限，笔记过程可能存在不妥之处） system/core/reboot/reboot.c intmain(intargc, char*argv[]) { // ....... ret= pro...
Android 10关机界面定制
mart!nhu的博客
07-29 2234
Android 10 定制关机界面
MT6735 - battery相关笔记 (充电、电池状态、zvc、driver与service通信)
shellshell13的专栏
12-20 9001
充电 kernel-3.18/drivers/misc/mediatek/include/mt-plat/mt6735/include/mach/mt_charging.h #define AC_CHARGER_CURRENT CHARGE_CURRENT_800_00_MA //先跑这个 kernel-3.18/arch/arm64/boot/dts/mt6735.dtsi /
STM32 RTC掉电存储技术及电池供电数据保护
开发者应该设计相应的机制来检测电池电量，并在电池状态不佳时提醒用户进行更换。 ### 结语 STM32微控制器的RTC模块是一个功能强大的时钟单元，它通过电池供电在掉电的情况下保障数据的持久性。正确地理解和运用RTC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值