ESP32修改BootLoader：在boot中添加GPIO和IIC驱动方式

最新推荐文章于 2024-05-17 10:00:00 发布
最新推荐文章于 2024-05-17 10:00:00 发布
阅读量1.8k 收藏 5
点赞数 2
分类专栏： ESP开发 文章标签： 嵌入式硬件 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinstruggle/article/details/128923279
版权

ESP32修改BootLoader：在boot中添加GPIO和IIC驱动方式

1. ESP Bootloader简介

ESP32有着强大的引导加载程序（Bootloader）功能：
主要执行以下任务：
内部模块的最小化初始配置；
根据分区表和 ota_data（如果存在）选择需要引导的应用程序（app）分区；
将此应用程序映像加载到 RAM（IRAM 和 DRAM）中，最后把控制权转交给应用程序。
引导加载程序位于 Flash 的 0x1000 偏移地址处。

2. Bootloader修改方式

这里引用C站一个作者的文章，写的不错：点这里
文章分为上下两篇，下篇。

当涉及到用户有特殊BootLoader功能需求时，需要用户自行修改，修改方式主要有：
通过钩子函数。扩展原来的bootloader流程，打个补丁。
通过覆盖bootloader。重写一个bootloader，覆盖原来bootloader的逻辑来运行。
可以发现，这两种方式一个针对小改动需求，一个针对大改动的需要。
怎么添加自己的功能
如果在应用层开发，会做些什么？

嗯，你会在component目录下新建自己功能名的文件夹
之后呢？不知道了… 那就看看component其他组件都放了啥吧。哦，有CMakeLists.txt，component.mk，还有代码目录。那咱们依葫芦画瓢，也放上这些东西。
然后？既然有Cmake的东西，那就看看里面都说了啥。哦，原来里面就是设置好了要编译哪些源文件，头文件目录在哪里，还有配置好编译选项啊，库路径什么的。

是的，这些东西在bootloader里面都有，方法类似。就我的开发方式而言，mycode放在bootloader_support目录下之后，里面的源文件、头文件、库这些的，都跟应用层开发一样。该在CMakeLists.txt加什么就加。
这跟在boot还是在app其实就没啥关系，是CMake这种跨平台编译方式的基本操作。

3. 我的修改方式

本文主要讲解其中一种修改方式：mycode放在bootloader_support目录下之后，里面的源文件、头文件、库这些的，都跟应用层开发一样。该在CMakeLists.txt加什么就加。

下图是本人在bootloader_support文件夹中添加的个人代码“tc2x”
在这里插入图片描述

并在CmakeLists.txt中添加需要编译的源文件和头文件目录
在这里插入图片描述

此时，完成了在bootloader_support添加自己的代码。

4. 修改bootloader_utility.c文件

如图，我的boot修改内容主要是基于boot跳转APP失败时，跑一段自己的驱动和应用。
在这里插入图片描述

5. 在bootloader中实现GPIO控制

实现代码：

#include <string.h>
#include <stdint.h>
#include <limits.h>
#include "esp_attr.h"
#include "esp_log.h"
#include "esp_err.h"
#include "esp_rom_sys.h"
#include "esp_rom_uart.h"
#include "sdkconfig.h"
#include "esp_rom_crc.h"
#include "esp_rom_gpio.h"
#include "esp_rom_efuse.h"
#include "soc/gpio_periph.h"
#include "soc/soc_caps.h"
#include "hal/gpio_ll.h"
#include "hal/gpio_types.h"

#define CFG_I2C_SCL_PORT   GPIO_PORT_0
#define CFG_I2C_SCL_PIN    18
#define CFG_I2C_SDA_PORT   GPIO_PORT_0
#define CFG_I2C_SDA_PIN    17

#define PIN_OUTPUT_ENABLE(PIN_NAME)               SET_PERI_REG_MASK(PIN_NAME,FUN_IE)
#define PIN_OUTPUT_DISABLE(PIN_NAME)              CLEAR_PERI_REG_MASK(PIN_NAME,FUN_IE)
void HAL_GPIO_WritePin(int gpio_port, int gpio_pin, int level)
{
    gpio_ll_set_level(&GPIO, gpio_pin, level);
}
uint8_t HAL_GPIO_ReadPin(int gpio_port, int gpio_pin)
{
    return gpio_ll_get_level(&GPIO, gpio_pin);
}
void HAL_GPIO_SetOut(int gpio_port, int gpio_pin)
{
    esp_rom_gpio_pad_select_gpio(gpio_pin);
    // if (GPIO_PIN_MUX_REG[gpio_pin]) {
    //     PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_pin]);
    //     PIN_SLP_OUTPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_pin]);
    // }
    esp_rom_gpio_pad_pullup_only(gpio_pin);
    gpio_ll_output_enable(&GPIO, gpio_pin);
    //gpio_ll_sleep_output_enable(&GPIO, gpio_pin);
}
void HAL_GPIO_SetIn(int gpio_port, int gpio_pin)
{
    esp_rom_gpio_pad_select_gpio(gpio_pin);
    // if (GPIO_PIN_MUX_REG[gpio_pin]) {
    //     PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_pin]);
    //     PIN_SLP_OUTPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_pin]);
    // }
    esp_rom_gpio_pad_pullup_only(gpio_pin);
    gpio_ll_input_enable(&GPIO, gpio_pin);
   // gpio_ll_sleep_input_enable(&GPIO, gpio_pin);
}

6. 在bootloader中实现IIC控制

代码实现：

void I2C_DELAY(uint32_t us)
{
    esp_rom_delay_us(us);
}
static const char* TAG = "[GPIOIIC]";

#define IIC1 0
#define IIC2 1
#define IICX 0XFF 
#define GPIO_PIN_SET   1 
#define GPIO_PIN_RESET 0  
static int I2C_SCL_PORT = 0;
static int I2C_SCL_PIN  = 18;
static int I2C_SDA_PORT = 0;
static int I2C_SDA_PIN  = 17;
#define us_num 2
#define I2C_READ_BIT                 (0x01)        //!< If this bit is set in the address field, transfer direction is from slave to master.
#define I2C_WRITE_BIT                (0xFE)

static void I2C_SEL(uint8_t I2Cn, uint8_t scl, uint8_t sda)
{
    switch(I2Cn)
    {
    case IIC1:
        I2C_SCL_PORT = CFG_I2C_SCL_PORT;
        I2C_SCL_PIN  = CFG_I2C_SCL_PIN;
        I2C_SDA_PORT = CFG_I2C_SDA_PORT;
        I2C_SDA_PIN  = CFG_I2C_SDA_PIN;
        break;
    case IIC2:
        I2C_SCL_PORT = CFG_I2C_SCL_PORT;
        I2C_SCL_PIN  = CFG_I2C_SCL_PIN;
        I2C_SDA_PORT = CFG_I2C_SDA_PORT;
        I2C_SDA_PIN  = CFG_I2C_SDA_PIN;
        break;
    default: 
        I2C_SCL_PORT = CFG_I2C_SCL_PORT;
        I2C_SCL_PIN  = scl;
        I2C_SDA_PORT = CFG_I2C_SDA_PORT;
        I2C_SDA_PIN  = sda;
        break;
    }
}
static void I2C_SCL_OUTPUT(void)
{
    HAL_GPIO_SetOut(I2C_SCL_PORT, I2C_SCL_PIN);
}
static void I2C_SCL_INPUT(void)
{
    HAL_GPIO_SetIn(I2C_SCL_PORT, I2C_SCL_PIN);
}
static void I2C_SCL_HIGH(void)
{
    HAL_GPIO_WritePin(I2C_SCL_PORT, I2C_SCL_PIN, GPIO_PIN_SET);
}
static void I2C_SCL_LOW(void)
{
    HAL_GPIO_WritePin(I2C_SCL_PORT, I2C_SCL_PIN, GPIO_PIN_RESET);
}
static void I2C_SDA_OUTPUT(void)
{
    HAL_GPIO_SetOut(I2C_SDA_PORT, I2C_SDA_PIN);
}
static void I2C_SDA_INPUT(void)
{
    HAL_GPIO_SetIn(I2C_SDA_PORT, I2C_SDA_PIN);
}
static void I2C_SDA_HIGH(void)
{
    HAL_GPIO_WritePin(I2C_SDA_PORT, I2C_SDA_PIN, GPIO_PIN_SET);
}
static void I2C_SDA_LOW(void)
{
    HAL_GPIO_WritePin(I2C_SDA_PORT, I2C_SDA_PIN, GPIO_PIN_RESET);
}
static uint8_t I2C_SDA_READ(void)
{
    return HAL_GPIO_ReadPin(I2C_SDA_PORT, I2C_SDA_PIN);
}
static uint8_t I2C_SCL_READ(void)
{
    return HAL_GPIO_ReadPin(I2C_SCL_PORT, I2C_SCL_PIN);
}
void I2C_SCL_SDA_TEST(void)
{
    I2C_SCL_OUTPUT();
    I2C_SDA_OUTPUT();
    I2C_SDA_HIGH();
    I2C_SDA_LOW();
}
static void I2C_Init(int scl, int sda)
{
    I2C_SEL(IICX, scl, sda);
    I2C_SCL_INPUT();
    I2C_SDA_INPUT();
    I2C_SCL_OUTPUT();
    I2C_SCL_HIGH();
    I2C_SDA_OUTPUT();
    I2C_SDA_HIGH();
}
static bool i2c_master_clear_bus(void);
static bool i2c_master_issue_startcondition(void);
static bool i2c_master_issue_stopcondition(void);
static bool i2c_master_clock_byte(uint_fast8_t databyte);
static bool i2c_master_clock_byte_in(uint8_t *databyte, bool ack);
static bool i2c_master_wait_while_scl_low(void);
bool gpioi2c_master_init(uint8_t sclpin, uint8_t sdapin)
{
    I2C_Init(sclpin, sdapin);
    return i2c_master_clear_bus();
}
static bool i2c_master_clear_bus(void)
{
    bool bus_clear;
    I2C_SDA_HIGH();
    I2C_SCL_HIGH();
    I2C_DELAY(1);
    if (I2C_SDA_READ() == 1 && I2C_SCL_READ() == 1)
    {
        bus_clear = true;
    }
    else if (I2C_SCL_READ() == 1)
    {
        bus_clear = false;
        ESP_LOGE(TAG, "i2c_master_clear_bus 1 fail");
        for (uint_fast8_t i = 18; i--;)
        {
            I2C_SCL_LOW();
            I2C_DELAY(1);
            I2C_SCL_HIGH();
            I2C_DELAY(1);
            if (I2C_SDA_READ() == 1)
            {
                bus_clear = true;
                break;
            }
        }
    }
    else
    {
        bus_clear = false;
         ESP_LOGE(TAG, "i2c_master_clear_bus 2 fail");
    }
    return bus_clear;
}
static bool i2c_master_issue_startcondition(void)
{
    I2C_SCL_OUTPUT();
    I2C_SDA_OUTPUT();
    I2C_SDA_HIGH();
    I2C_DELAY(1);
    if (!i2c_master_wait_while_scl_low())
    {
        ESP_LOGE(TAG, "i2c_master_wait_while_scl_low fail");
        return false;
    }
    I2C_SDA_LOW();
    I2C_DELAY(1);
    // Other module function expect SCL to be low
    I2C_SCL_LOW();
    I2C_DELAY(1);
    return true;
}
static bool i2c_master_issue_stopcondition(void)
{
    I2C_SDA_LOW();
    I2C_DELAY(1);
    if (!i2c_master_wait_while_scl_low())
    {
        ESP_LOGE(TAG, "i2c_master_issue_stopcondition fail");
        return false;
    }
    I2C_SDA_HIGH();
    I2C_DELAY(1);
    return true;
}
static bool i2c_master_clock_byte(uint_fast8_t databyte)
{
    bool transfer_succeeded = true;
    I2C_SDA_OUTPUT();
    // MSB first
    for (uint_fast8_t i = 0x80; i != 0; i >>= 1)
    {
        I2C_SCL_LOW();
        I2C_DELAY(1);
        if (databyte & i)
        {
            I2C_SDA_HIGH();
        }
        else
        {
            I2C_SDA_LOW();
        }
        if (!i2c_master_wait_while_scl_low())
        {
            ESP_LOGE(TAG, "i2c_master_clock_byte fail");
            transfer_succeeded = false; // Timeout
            break;
        }
    }
    I2C_SCL_LOW();
    I2C_DELAY(1);
    I2C_SDA_INPUT();
    I2C_DELAY(1);
    transfer_succeeded &= i2c_master_wait_while_scl_low();
    transfer_succeeded &= !(I2C_SDA_READ());
    I2C_SCL_LOW();
    I2C_DELAY(1);
    I2C_SDA_OUTPUT();
    return transfer_succeeded;
}
static bool i2c_master_clock_byte_in(uint8_t *databyte, bool ack)
{
    uint_fast8_t byte_read          = 0;
    bool         transfer_succeeded = true;
    I2C_SDA_INPUT();
    for (uint_fast8_t i = 0x80; i != 0; i >>= 1)
    {
        if (!i2c_master_wait_while_scl_low())
        {
            ESP_LOGE(TAG, "i2c_master_clock_byte_in 1 fail");
            transfer_succeeded = false;
            break;
        }
        if (I2C_SDA_READ())
        {
            byte_read |= i;
        }
        else
        {
            // No need to do anything
        }
        I2C_SCL_LOW();
        I2C_DELAY(1);
    }
    I2C_SDA_OUTPUT();
    *databyte = (uint8_t)byte_read;
    if (ack)
    {
        I2C_SDA_LOW();
    }
    else
    {
        I2C_SDA_HIGH();
    }
    I2C_DELAY(1);
    if (!i2c_master_wait_while_scl_low())
    {
        ESP_LOGE(TAG, "i2c_master_clock_byte_in 2 fail");
        transfer_succeeded = false; // Timeout
    }
    I2C_SCL_LOW();
    I2C_DELAY(1);
    return transfer_succeeded;
}
static bool i2c_master_wait_while_scl_low()
{
    uint8_t timeout_counter = 30;
    I2C_SCL_HIGH();
    I2C_DELAY(1);
    while (I2C_SCL_READ() == 0)
    {
        if (timeout_counter-- == 0)
        {
            ESP_LOGE(TAG, "i2c_master_wait_while_scl_low fail");
            return false;
        }
        else
        {
            I2C_DELAY(3);
        }
    }
    return true;
}
bool gpioi2c_master_read(uint8_t address, uint8_t reg_addr, uint8_t * data, uint8_t data_length, bool issue_stop_condition)
{
    bool transfer_succeeded = true;
    transfer_succeeded &= i2c_master_issue_startcondition();
    transfer_succeeded &= i2c_master_clock_byte(address&I2C_WRITE_BIT);
    /** send the address of register which you want to read*/
    transfer_succeeded &= i2c_master_clock_byte(reg_addr);
    /** must send 2 times start condition */
    transfer_succeeded &= i2c_master_issue_startcondition();
    transfer_succeeded &= i2c_master_clock_byte(address|I2C_READ_BIT);
    /* Transfer direction is from Slave to Master */
    while (data_length-- && transfer_succeeded)
    {
        // To indicate to slave that we've finished transferring last data byte
        // we need to NACK the last transfer.
        if (data_length == 0)
        {
            transfer_succeeded &= i2c_master_clock_byte_in(data, (bool)false);
        }
        else
        {
            transfer_succeeded &= i2c_master_clock_byte_in(data, (bool)true);
        }
        data++;
    }
    if (issue_stop_condition || !transfer_succeeded)
    {
        transfer_succeeded &= i2c_master_issue_stopcondition();
    }
    return transfer_succeeded;
}


bool gpioi2c_master_write(uint8_t address, uint8_t reg_addr, uint8_t * data, uint8_t data_length, bool issue_stop_condition)
{
    bool transfer_succeeded = true;
    
    transfer_succeeded &= i2c_master_issue_startcondition();
ESP_LOGD(TAG, "gpioi2c_master_write transfer_succeeded1=%d",transfer_succeeded);
    transfer_succeeded &= i2c_master_clock_byte(address&I2C_WRITE_BIT);
ESP_LOGD(TAG, "gpioi2c_master_write transfer_succeeded2=%d",transfer_succeeded);
    /** send the address of register which you want to write */
    transfer_succeeded &= i2c_master_clock_byte(reg_addr);
ESP_LOGD(TAG, "gpioi2c_master_write transfer_succeeded3=%d",transfer_succeeded);
    /* Transfer direction is from Master to Slave */
    while (data_length-- && transfer_succeeded)
    {
        transfer_succeeded &= i2c_master_clock_byte(*data);
        data++;
    }
    if (issue_stop_condition || !transfer_succeeded)
    {
        transfer_succeeded &= i2c_master_issue_stopcondition();
ESP_LOGD(TAG, "gpioi2c_master_write transfer_succeeded4=%d",transfer_succeeded);
    }
    return transfer_succeeded;
}

7. 总结

通过以上方式，可以实现在esp32修改BootLoader代码，并实现GPIO和IIC驱动，从而实现自己的修改需求。

嵌入式那个小哥
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ESP32、ESP8266/85增强型透传固件 JFirmware v1.2.1+v1.3（含bootloader和分区配置）
10-18
ESP32、ESP8266/85增强型透传固件 JFirmware v1.2.1+v1.3（含bootloader和分区配置） 补充了之前漏发的ESP32的bootloader和分区信息，重新打包
深入解析ESP32C3（3）- bootloader启动流程
Golden_Chen的专栏
02-17 2151
ESCP32C3引导程序的详细开机流程
【填坑】ESP32 bootloader初探（下）
Casey的博客
09-13 4146
我由于做软件业务的需要，在这几年开发经历中，发现一个现象：各家芯片厂商boot开放的资料较少，不支持或少量支持定制化功能。可能也是需求少吧，毕竟对基线的改动需要的工作量也不小。但这也导致各家芯片的boot开发体验都不是太顺畅，开发者要自己摸索boot的一些定制化实现方案。这篇内容接着上一篇 =>，看看bootloader里我是怎么搞定外设使用的。
ESP32启动流程（超级详细！！！）
最新发布
古月居
05-17 653
如果 RTC_CNTL_STORE6_REG 的值非零，并且 RTC_CNTL_STORE7_REG 的 CRC 校验有效，则跳转到 RTC_CNTL_STORE6_REG 指定的地址执行代码。在复位之后，PRO CPU 首先被激活，开始执行位于 ESP32 芯片掩膜 ROM 中的复位向量代码（复位向量代码是指在微控制器或其他类型的处理器中，在复位事件发生后首先执行的一段代码）系统检查 RTC_CNTL_STORE6_REG 和 RTC_CNTL_STORE7_REG 寄存器的值。，不参与初始化过程。
【填坑】ESP32 bootloader初探（上）
Casey的博客
09-04 5960
大名鼎鼎的乐鑫ESP8266 WIFI模组你应该不陌生，不用我多说了。在这之后乐鑫还更迭了更多高性能的芯片型号，比如这次我要记录的ESP32-C3，搭载近期很火的RISC-V指令集处理器，支持2.4G wifi、BLE-5，拥有丰富应用场景。是的，它很好。至少硬件很强大，不过再牛批的硬件也需要众多开发者的实践经验来不断完善它的生态。
ESP32 - 使用VisualMicro开发ESP32遇到问题：找不到引导加载程序(bootloader.bin)
猿长大人
02-19 1771
使用VisualMicro开发ESP32时无法烧写到板子里，提示信息提示找不到**bootloader.bin**文件
ESP32学习笔记
weixin_74209371的博客
02-03 1853
ESP32学习笔记
【ESP32-S2】ESP32-S2从服务器下载STM32F103ZET6的bin固件再使用Ymodem通讯实现bootloader
sgd985437的博客
11-22 2535
STM32的bootloader： 两个代码 1、bootloader代码，实现初始化选择运行的固件 2、APP代码，实现更新后的固件 注意：需要先连接到路由器才能使用http连接的初始化函数 两种升级方案：1、单片机自带tcpip协议 2、单片机+tcpip协议的模块 可见要么是stm32自己能够上网，要么外带一个能够上网的模块。其中要解决的技术点为 1.单片机的bootloader 以及http协议解析下载固件 2.单片机的bootloader 以及模块的http协议下载固件 3.若要本地测试兼容
STM32上添加bootloader+application，在外部flash中备份及升级程序
01-06
近期看到一篇关于bootloader的博文，亲手也尝试了一下，这里做下笔记，方便日后查看，根据项目修改可以加个DTU，用服务器远程升级一下程序。 一、工程配置 使用的是stm32f103vet6芯片，512的ROM，64kRAM，外部flash...
ESP32-S3驱动ILI9488 串口SPI显示屏完整例程
06-21
★ lv_port_esp32_master例程更改部分BUG，实现了用ESP32-S3 配ILI9488 SPI屏。 SPI2接口驱动，能正常显示lv_port_esp32_master例程。 SPI3接口驱动，能XPT2046触控交互。 ★ 编译环境 Visual Studio Code + IDF ...
stm32-tkg-hid-bootloader:用于STM32F1系列的HID无驱动程序引导加载程序和Flash工具伴侣
05-07
在此处检查适用于Windows和Linux平台的二进制发行版的最新发行版：STM32F10x TKG-HID-BOOTLOADER 这是用于STM32F10x系列产品线（包括著名的Bluepill）的HID（人机接口设备）无驱动程序的booloader。 它的灵感来自...
tasmota国内烧写ESP32模块专用固件
10-05
tasmota国内烧写ESP32模块专用固件 boot_app0.bin,bootloader_dio_40m.bin,partitions.bin,tasmota32-CN.bin 使用说明见以下地址：https://blog.csdn.net/ttt105/article/details/120550780?spm=1001.2014.3001.5502
stm32-hid-bootloader:适用于STM32F10X器件的无驱动USB HID引导加载程序和刷新工具
05-03
这是用于STM32F10X器件的无驱动程序的USB HID引导程序（即使在Windows上也不需要USB驱动程序）。 它不使用ST库，因为它们很肿且有故障。 ST提供的SDK仅使用了CMSIS以及一些必需的系统文件和宏。 这允许一个非常小...
ESP32 官方文档（十二）Bootloader (引导加载程序)
InfiniteYuan
09-02 6221
Bootloader 引导加载程序执行以下功能： 内部模块的最初初始配置; 根据分区表和 ota_data(如果有),选择要引导的应用程序分区; 将此映像加载到 RAM(IRAM 和 DRAM) 并将管理传输到它. 引导加载程序位于 Flash 中的地址 0x1000. 恢复出厂设置 用户可以编写基本工作固件并将其加载到 factory 分区.接下来,通过 OTA(无线)更新固...
易灵思软核Riscv-Sapphire的bootloader的配置及修改的相关操作
汏檤臸彅*潙涳洂涳
06-02 1498
易灵思 Sapphire软核开发
ESP32：系统初始化启动过程
weixin_34226706的博客
11-24 984
esp32开发程序中有且只能有一个app_main函数，该函数是用户程序的入口，相当于其它系统中的main函数。但在app_main之前，系统还有一段初始化的过程，其大致可以分为以下三个过程： ROM中的第一级引导加载程序将闪存偏移0x1000的第二级引导加载程序映像加载到RAM（IRAM和DRAM）； 第二级引导程序从闪存加载分区表...
从0写bootloader — 最简单的bootloader和App
欲盖弥彰1314
07-09 1721
对于空间划分是人为定义的。 启动文件start.s： 最简单的启动，暂时不使用中断向量。 如果是通过MDK设置链接地址，不勾选(不使用Target对话框的内存布局) 遇到的问题：必须到导出中断向量全局可见，不然程序无法启动：链接地址通过散列文件指定： 这是创建工程默认创建的散列文件 usart.c： 只使用串口打印简单的信息 main.c: 烧录程序上电运行，打印信息： bootloader正常运行。 从自定义划分的地址看，APP开始的地址是 这里为什么跳转使用的是呢？ 原因是STM32是Cortex-M
stm32 bootloader 跳转 gpio保持状态
06-12
当使用STM32 Bootloader跳转到应用程序时，GPIO的状态可能会被重置。为了保持GPIO的状态，您可以在应用程序中使用GPIO初始化代码来重新设置GPIO的状态。 具体来说，您可以在应用程序中使用HAL库来初始化GPIO，并将其设置为与Bootloader相同的状态。在这种情况下，您需要注意以下几点： 1. 确保应用程序中使用的GPIO与Bootloader中使用的GPIO是相同的。 2. 在应用程序中初始化GPIO的代码应与Bootloader中使用的代码相同。 3. 如果在Bootloader中使用了外部中断，那么在应用程序中需要重新启用这些中断。 通过这些步骤，您可以保持GPIO的状态，并在应用程序中继续使用它们。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值