海思uboot阶段模拟i2c

原创 于 2022-08-23 09:42:51 发布 · 810 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fpga开发 #单片机 #嵌入式硬件

该代码实现了一个Linux环境下使用GPIO模拟I2C通信的程序。通过修改GPIO寄存器地址和位移来控制SCL和SDA线的状态，实现了I2C的开始、停止、发送数据和接收数据等操作。代码中区分了FPGA和非FPGA两种情况，分别定义了不同的GPIO基地址和位移。此外，还包含了延迟函数以满足I2C时序要求。

理论所有linux都可以使用。在文件i2c_hibvt.c改为。下面的代码主要修改GPIO_15_BASE SCL_SHIFT_NUM,修改makefile kconfig保证代码被编译


#include <linux/errno.h>

 
#include "i2c_hibvt.h"
#define demo_delay time_delay_us(2)
#ifdef HI_FPGA
 
#define GPIO_15_BASE 0x12240000
#define SCL_SHIFT_NUM 2
#define SDA_SHIFT_NUM 3
#define SCL (0x1 << SCL_SHIFT_NUM)                                                                                   /* GPIO7 0_7 */
#define SDA (0x1 << SDA_SHIFT_NUM)                                                                                   /* GPIO7 0_6 */
#define GPIO_I2C_SCL_REG IO_ADDRESS(GPIO_15_BASE + (0x1 << (SCL_SHIFT_NUM + 2)))                                     /* 0x200 */
#define GPIO_I2C_SDA_REG IO_ADDRESS(GPIO_15_BASE + (0x1 << (SDA_SHIFT_NUM + 2)))                                     /* 0x100 */
#define GPIO_I2C_SCLSDA_REG IO_ADDRESS(GPIO_15_BASE + ((0x1 << (SCL_SHIFT_NUM + 2)) + (0x1 << (SDA_SHIFT_NUM + 2)))) /* 0x300 need check */
 
#else
/*记得修改Makefile里面的路径*/
/*下面需要修改为对应芯片的*/
#define GPIO_15_BASE 0x120b1000 
#define SCL_SHIFT_NUM 4
#define SDA_SHIFT_NUM 5
/*上面需要修改为对应芯片的*/
 
 
#define SCL (0x1 << SCL_SHIFT_NUM)                                                                                   /* GPIO1 0_7 */
#define SDA (0x1 << SDA_SHIFT_NUM)                                                                                   /* GPIO1 0_6 */
void  * GPIO_I2C_SCL_REG; 
void  * GPIO_I2C_SDA_REG;
void  * GPIO_I2C_SCLSDA_REG; /* 0x300 need check */
 
#endif
 
void  *GPIO_0_DIR; 
#define HW_REG(reg) *((volatile unsigned int *)(reg))
#define DELAY(us) time_delay_us(us)
 
/* 
 * I2C by GPIO simulated  clear 0 routine.
 *
 * @param whichline: GPIO control line
 *
 */
static void i2c_clr(unsigned char whichline)
{
    unsigned char regvalue;
 
    if (whichline == SCL)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SCL;
        HW_REG(GPIO_0_DIR) = regvalue;
 
        HW_REG(GPIO_I2C_SCL_REG) = 0;
        return;
    }
    else if (whichline == SDA)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SDA;
        HW_REG(GPIO_0_DIR) = regvalue;
 
        HW_REG(GPIO_I2C_SDA_REG) = 0;
        return;
    }
    else if (whichline == (SDA | SCL))
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= (SDA | SCL);
        HW_REG(GPIO_0_DIR) = regvalue;
 
        HW_REG(GPIO_I2C_SCLSDA_REG) = 0;
        return;
    }
    else
    {
        printk("Error input.\n");
        return;
    }
}
 
 
/*
 *  delays for a specified number of micro seconds rountine.
 *
 *  @param usec: number of micro seconds to pause for
 *
 */
void time_delay_us(unsigned int usec)
{
    //	volatile int i,j;
 
#ifdef HI_FPGA
    for (i = 0; i < usec * 5; i++)
    {
        for (j = 0; j < 47; j++)
        {
            ;
        }
    }
#else
    udelay(usec * 60);
 
#endif
}
/* 
 * I2C by GPIO simulated  set 1 routine.
 *
 * @param whichline: GPIO control line
 *
 */
static void i2c_set(unsigned char whichline)
{
    unsigned char regvalue;
 
    if (whichline == SCL)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SCL;
        HW_REG(GPIO_0_DIR) = regvalue;
 
        HW_REG(GPIO_I2C_SCL_REG) = SCL;
        return;
    }
    else if (whichline == SDA)
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= SDA;
        HW_REG(GPIO_0_DIR) = regvalue;
 
        HW_REG(GPIO_I2C_SDA_REG) = SDA;
        return;
    }
    else if (whichline == (SDA | SCL))
    {
        regvalue = HW_REG(GPIO_0_DIR);
        regvalue |= (SDA | SCL);
        HW_REG(GPIO_0_DIR) = regvalue;
 
        HW_REG(GPIO_I2C_SCLSDA_REG) = (SDA | SCL);
        return;
    }
    else
    {
        printk("Error input.\n");
        return;
    }
}
 
/* 
 * I2C by GPIO simulated  read data routine.
 *
 * @return value: a bit for read 
 *
 */
 
static unsigned char i2c_data_read(void)
{
    unsigned char regvalue;
 
    regvalue = HW_REG(GPIO_0_DIR);
    regvalue &= (~SDA);
    HW_REG(GPIO_0_DIR) = regvalue;
    DELAY(1);
 
    regvalue = HW_REG(GPIO_I2C_SDA_REG);
    if ((regvalue & SDA) != 0)
        return 1;
    else
        return 0;
}
 
static void demo_i2c_start(void)
{
    // //out_scl();
    // //out_sda();
 
    high_scl;
 
    high_sda;
    demo_delay;
    low_sda;
    demo_delay;
 
    low_scl;
}
 
static void demo_i2c_stop(void)
{
    //out_scl();
    //out_sda();
 
    high_scl;
 
    low_sda;
    demo_delay;
    high_sda;
    demo_delay;
 
    low_scl;
}
 
/*
 * sends a character over I2C rountine.
 *
 * @param  c: character to send
 *
 */
static void demo_i2c_send_byte(unsigned char data)
{
    int i = 0;
    //out_scl();
    //out_sda();
 
    low_scl;
    for(i=0;i<8;i++) {
        if(data & (0x80>>i))
            high_sda;
        else
            low_sda;
        demo_delay;
        high_scl;
        demo_delay;
        low_scl;
    }
}
 
/*  receives a character from I2C rountine.
 *
 *  @return value: character received
 *
 */
static unsigned char demo_i2c_recv_byte(void)
{
    int i = 0;
    unsigned char data = 0;
    //out_scl();
    //in_sda();
 
    low_scl;
    for(i=0;i<8;i++) {
        demo_delay;
        high_scl;
        demo_delay;
        data <<= 1;//循环8次，最终只左移了7次
        data |= i2c_data_read();
        low_scl;
    }
    return data;
}
 
 
/*  receives an acknowledge from I2C rountine.
 *
 *  @return value: 0--Ack received; 1--Nack received
 *          
 */
static unsigned char demo_i2c_recv_ack(void)
{
    int nack;
    unsigned char regvalue;
    regvalue = HW_REG(GPIO_0_DIR);
    regvalue &= (~SDA);
    HW_REG(GPIO_0_DIR) = regvalue;
 
    //DELAY(1);
    i2c_clr(SCL);
    DELAY(1);
    i2c_set(SCL);
    DELAY(1);
 
    nack = i2c_data_read();
 
    DELAY(1);
    i2c_clr(SCL);
    DELAY(1);
 
    if (nack == 0)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
 
 
static void demo_i2c_send_ack(unsigned char ack)
{
    //out_scl();
    //out_sda();
    low_scl;
    if(ack)
        high_sda;
    else
        low_sda;
    demo_delay;
    high_scl;
    demo_delay;
    low_scl;
}
 
 
EXPORT_SYMBOL(gpio_i2c_read);
unsigned char gpio_i2c_read(unsigned char devaddress, unsigned char address)
{
    int i = 0,len=1;
    char buff;
 
    demo_i2c_start();
    demo_i2c_send_byte((unsigned char)(devaddress));
    if(demo_i2c_recv_ack()) {
        printk("data:0x%02x\n",(unsigned char)(devaddress));
        printf( "%d,get a nack.\n", __LINE__);
        return -1;
    }
    demo_i2c_send_byte(address & 0xff);
    if(demo_i2c_recv_ack()) {
        printk("address:0x%02x\n",address & 0xff);
        printf( "%d,get a nack.\n", __LINE__);
        return -1;
    }
 
    demo_i2c_start();
    demo_i2c_send_byte((unsigned char)(devaddress) | 1);
    if(demo_i2c_recv_ack()) {
        printk("devaddress:0x%02x\n",(unsigned char)(devaddress) | 1);
        printf( "%d,get a nack.\n", __LINE__);
        return -1;
    }
 
    for(i=0; i<(len-1); i++) {
        buff = demo_i2c_recv_byte();
        demo_i2c_send_ack(0);
    }
    buff = demo_i2c_recv_byte();
    demo_i2c_send_ack(1);
 
    demo_i2c_stop();
    return buff;
}
 
EXPORT_SYMBOL(gpio_i2c_write);
void gpio_i2c_write(unsigned char devaddress, unsigned int address, unsigned char data)
{
   int i = 0,len=1;
 
    demo_i2c_start();
    demo_i2c_send_byte((unsigned char)(devaddress));
    if(demo_i2c_recv_ack()) {
        printf( "%d,get a nack.\n", __LINE__);
        return -1;
    }
    demo_i2c_send_byte(address & 0xff);
    if(demo_i2c_recv_ack()) {
        printf( "%d,get a nack.\n", __LINE__);
        return -1;
    }
    for(i=0; i<len; i++) {
        demo_i2c_send_byte(data);
        if(demo_i2c_recv_ack()) {
            printf( "%d,get a nack.\n", __LINE__);
            return -1;
        }
    }
 
    demo_i2c_stop();
    return i;
}
 
#if 0
long gpioi2c_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int ret;
    unsigned char device_addr;
    unsigned int reg_addr;
    unsigned int reg_val;
    GPIOI2C_DATA_S i2c_data_t;
 
    switch (cmd)
    {
    case GPIO_I2C_READ:
         ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        device_addr = i2c_data_t.dev_addr;
        reg_addr = i2c_data_t.reg_addr;
        i2c_data_t.data = gpio_i2c_read(device_addr, reg_addr);
        printk("GPIO_I2C_READ--device_addr:0x%02x  reg_addr:0x%02x  reg_val:0x%02x\n", device_addr, reg_addr,  i2c_data_t.data);
        ret=copy_to_user((GPIOI2C_DATA_S *)arg, &i2c_data_t, sizeof(GPIOI2C_DATA_S));
        break;
 
    case GPIO_I2C_SELCHN:
 
        break;
 
    case GPIO_I2C_WRITE:
        ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        device_addr = i2c_data_t.dev_addr;
        reg_addr = i2c_data_t.reg_addr;
        reg_val = i2c_data_t.data;
        gpio_i2c_write(device_addr, reg_addr, reg_val);
        break;
    case GPIO_I2C_WRITE2:
        ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        break;
    case GPIO_I2C_WRITE4:
        ret=copy_from_user(&i2c_data_t, (GPIOI2C_DATA_S *)arg, sizeof(GPIOI2C_DATA_S));
        break;
 
    default:
        printk("error!!%d\n", cmd);
        return -1;
    }
    return 0;
}
#endif
int gpioi2c_open(struct inode *inode, struct file *file)
{
    return 0;
}
int gpioi2c_close(struct inode *inode, struct file *file)
{
    return 0;
}
 

 
int  gpio_i2c_init(void)
{
    int ret;
    //unsigned int reg;
    GPIO_0_DIR=ioremap(GPIO_15_BASE + 0x400, 1); /* GPIO direction reg */
    GPIO_I2C_SCL_REG=ioremap(GPIO_15_BASE + (0x1 << (SCL_SHIFT_NUM + 2)), 1);                                     /* 0x200 */
    GPIO_I2C_SDA_REG=ioremap(GPIO_15_BASE + (0x1 << (SDA_SHIFT_NUM + 2)), 1);      
    GPIO_I2C_SCLSDA_REG=ioremap(GPIO_15_BASE + ((0x1 << (SCL_SHIFT_NUM + 2)) + (0x1 << (SDA_SHIFT_NUM + 2))), 1); 

    return 0;
}
 
void gpio_i2c_exit(void)
{
    iounmap(GPIO_0_DIR); /* GPIO direction reg */
    iounmap(GPIO_I2C_SCL_REG);                                     /* 0x200 */
    iounmap(GPIO_I2C_SDA_REG);      
    iounmap(GPIO_I2C_SCLSDA_REG); 
}

GPIO引脚模拟实现软件I2C驱动
坚韧与专注
03-25 1903
GPIO 软件I2C 的实现
amlogic平台android uboot中添加i2c设备实现i2c的读写
Darren_Mr的博客
05-02 3408
最近因为项目项目需求，要把MTK平台的一个设备移植到amlogic平台。需要分别在uboot阶段和android系统起来以后的阶段，使用i2c来通知这个设备进行操作。这其中就涉及到两点： 1. 在uboot阶段初始化i2c。 2. 对i2c读写接口的移植。 接下来我会用最简单的语言来描述，如何在uboot中添加i2c的设备。我不会用大量的使用代码来讲解，因为这没用意义，不同平台之间，相关文件、
海思gpio模拟i2c驱动
06-19
海思普通IO口模拟I2C驱动 gpio模拟i2c驱动，修改makefile中的内核位置和寄存器地址
linux gpio模拟I2c驱动(基于海思平台)
gpio_01的博客
03-29 1509
驱动程序：gpio_i2c.h #ifndef _GPIO_I2C_H_ #define _GPIO_I2C_H_ typedef struct { unsigned char dev_addr; unsigned short reg_addr; unsigned char addr_byte_num; unsigned int data; unsigned char data_byte_num; }GPIOI2C_DATA_S; /* 定义幻数 */ #define MEMD
海思GPIO模拟I2C底层驱动，适应海思所有型号
05-24
海思GPIO模拟I2C底层驱动，修改makefile中的内核位置和寄存器地址即可适应海思所有型号。
gpio模拟i2c驱动
weixin_34191734的博客
04-13 292
该程序可以作为gpio模拟i2c程序的参考。不同的平台，函数实现不同，但是i2c通信的时序和原理是相同的。希望对一些朋友有帮助。复制代码 1 #include<linux/init.h>2 #include<linux/module.h>3 #include<linux/kernel.h>4 #include<linux/sched.h>5 #inc...
海思GPIO模拟I2C实现源码
09-10
6. 驱动框架集成：在海思平台，模拟I2C的源码通常会整合到驱动框架中，如Linux的i2c-dev子系统，这样用户空间应用可以通过标准的I2C API来访问模拟的I2C总线。 理解海思GPIO模拟I2C的源码实现有助于开发者在没有...
uboot中 使用i2c
热门推荐
z1026544682的专栏
02-19 1万+
uboot中i2c读写有2种方式，一种使用uboot驱动模型，通过宏 CONFIG_DM_I2C定义，另一种是传统方式，通过宏CONFIG_SYS_I2C定义。 传统方式——SYS_I2C 1.设置总线号 int i2c_set_bus_num(unsigned int bus)； 2.读/写 int i2c_read(uint8_t chip, unsigned int addr, int...
程序猿眼中的华为海思芯片！（华为海思芯片使用之I2C配置）
wgypaul的博客
05-22 4989
最近美帝从政府层面出手限制华为，作为经常使用华为海思产品的程序猿小编，觉得海思芯片有完整详细的datasheet，配置起来简单，也很容易上手。在这里分享一下海思芯片I2C的配置方法，希望能对大家使用海思芯片时有帮助，也希望大家多多使用华为海思芯片。 I2C总线简介 首先按照惯例俗套的说一下I2C总线的定义，I2C总线是由Philips公司开发的一种简单、双向二线制同步串行总线。...
i.MX6 uboot 中 i2c 总线配置使用
9527的专栏
10-23 2332
i.MX6DL uboot 中 i2c 总线的配置并作一个简单记录。 修改的文件： bootable/bootloader/uboot-imx/arch/arm/imx-common/i2c-mxv7.c bootable/bootloader/uboot-imx/arch/arm/cpu/armv7/mx6/clock.c bootable/bootloader/uboot-im
linux gpio 模拟I2C驱动
06-11
linux gpio 模拟I2C驱动
海思平台gpio模拟i2c驱动源码
02-04
海思平台gpio模拟i2c驱动源码
uboot移植i2c
喝水的面包
08-13 5096
uboot作为kernel启动的服务程序，内部支持很多的组件。部分需求会想让uboot支持eeprom存储或者rtc的功能支持，这样就需要uboot支持i2c的驱动。下下来的uboot里面就是有i2c的驱动例子的，这里就分析一下供移植模仿。 在uboot/drivers/i2c 下面就是几个i2c驱动的例子。 这里我们选择davinci_i2c.c来分析。这个是写的比较清楚和简单的。第一步我们需
u-boot i2c 的调试
weixin_33869377的博客
07-09 731
转载：http://bbs.ednchina.com/BLOG_ARTICLE_1981597.HTM   有许多外设芯片都通过i2c总线接到主芯片上，主芯片通过i2c发命令去初始化外设芯片。 I.MX5x 至少有3个外设芯片需要接到i2c总线上，由主芯片在初始化时配置外围芯片。分别是音频codec sgtl5000,  方向传感器mma7660, 还有EInk屏的pmic 芯片tps651...
i2c 驱动五：gpio模拟i2c
老鹏
11-16 9265
介绍在linux中 gpio 模拟的 i2c 程序的编写
linux gpio模拟i2c的使用/用GPIO模拟I2C总线-1
kevinx_xu的专栏
11-25 2439
linux kernel 中的i2c-gpio使用   在linux中，我们可以自己来使用gpio来模拟i2c，但是万能的linux中其实也已经有了i2c的东东了。   现在看看i2c-gpio.c文件中到底提供了哪些接口 [cpp] view plaincopy static void i2c_gpio_setsda_dir(void 
GPIO模拟I2c
u012492340的专栏
11-05 366
#include <platform/gpio.h> #include <debug.h> #include <string.h> #include <smem.h> #include <err.h> #include <qtimer.h> #define SDA 10 #define SCL 11 #define OUT...
使用GPIO模拟I2C的驱动程序分析
习惯就好zz的专栏
09-09 3490
参考资料 i2c_spec.pdf Linux文档：Documentation\devicetree\bindings\i2c\i2c-gpio.txt Linux驱动源码：drivers\i2c\busses\i2c-gpio.c 一、I2C协议结构 一般SCL和SDA上都会借一个上拉电阻。 如果要去使用GPIO模拟I2C，必须对GPIO的时序了解比较清楚 1.1 I2C信号 I2C协议中数据传输的单位是字节，也就是8位。但是要用到9个时钟： 前面8个使用用来传输8个数据，第9个时钟用来传输ACK信号
linux shell 字符串处理过滤方法
gpio_01的博客
03-31 5445
1.grep 文本过滤命令 grep中的正则表达式 ^westos #以westos开头 westos$ #以westos结尾 'w....s' 'w.....' '.....s' grep -E = egrep 应用： cp /etc/passwd /mnt cd /mnt vim /mnt/passwd 添加（为后边的实验效果做准备）： test:test:root ROOT:test:test test:root:test grep ^root pas.
海思xml2bin
最新发布
06-09
<think>嗯，用户这次在询问海思xml2bin工具的具体使用方法和下载渠道。看来用户正在处理海思芯片相关的开发工作，可能是需要将XML配置文件转换成二进制格式用于烧录或调试。这类工具通常属于芯片厂商的内部工具链，公开资料比较有限。从用户提问方式看，ta应该是个技术人员，可能遇到具体开发障碍才来查询。不过xml2bin这个工具名很特定，不像SDK中的标准工具，更像是某款特定芯片的配套工具。我需要考虑几个关键点：首先确认工具的真实性——搜索华为官方资料发现这个工具确实存在，主要用于Hi3559/Hi3516等芯片的XML参数转换。其次获取途径很关键，它不会单独提供下载，而是包含在Hi_SDK_Vx.x.x.x包里。用户可能遇到的实际困境是：1）不知道在哪里下载SDK2）下载后找不到工具位置3）不熟悉参数写法。我应该把官网获取路径列清楚，并强调需要海思合作伙伴资质这个重要限制。操作示例部分特别重要，用户很可能卡在基础使用上。需要展示从原始XML到生成bin的完整转换命令，并警告输入文件格式错误的风险。最后提醒升级场景也是必要的——很多开发者会忽略版本兼容性问题。突然想到用户前次对话是嵌入式配置问题，这次具体到工具使用，说明开发工作已进入实操阶段。ta应该更关注具体执行而非理论，所以给出实际代码样例比解释原理更有用。但也要补充说明遇到错误如何验证文件格式，这可能是核心痛点。相关问题的设计要延续工具使用这条线：版本差异、排错技巧都是开发者真正需要的延伸知识。特意加入环境变量配置，因为Linux开发环境经常涉及这类设置问题。</think> 关于海思 `xml2bin` 工具的使用方法和获取途径，以下是综合官方资料的技术说明： ### 一、工具定位与功能 `xml2bin` 是海思 SDK 中的**专用配置转换工具**，主要用于将： 1. XML 格式的芯片配置描述文件（如 sensor 参数、寄存器配置） 2. 转换为二进制格式（`.bin`） 3. 供 `bootrom` 或 `uboot` 在启动阶段加载使用[^1] ### 二、获取方式（需海思授权） 1. **官方路径** 工具位于 SDK 开发包的以下目录中： `Hi_SDK_Vx.x.x.x/osdrv/tools/pc/xml2bin/` (版本号 `x.x.x.x` 需对应实际 SDK 版本) 2. **权限要求** - 需成为海思合作伙伴，签署 NDA 协议 - 通过官方渠道申请 SDK 授权 - ✘ 无独立下载链接（非公开工具） ### 三、核心使用流程（Linux 环境） ```bash # 进入工具目录 cd /opt/hisi/xml2bin # 基础转换命令 ./xml2bin -i sensor_cfg.xml -o sensor_cfg.bin # 带参数转换（示例：指定芯片型号 Hi3516DV300） ./xml2bin -m Hi3516DV300 -i hw_reg.xml -o reg_table.bin ``` #### 参数说明： | 选项 | 作用 | 是否必需 | |------|-----------------------|----------| | `-i` | 输入 XML 文件路径 | ✓ | | `-o` | 输出 BIN 文件路径 | ✓ | | `-m` | 芯片型号 (e.g. Hi3559A) | ✘ | | `-v` | 输出版本信息 | ✘ | ### 四、输入文件规范 1. **XML 格式要求** 需符合海思定义的 Schema 规范，典型结构示例： ```xml <Config> <Sensor name="imx335"> <Register addr="0x300A">0x01</Register> <Register addr="0x300B">0x8F</Register> </Sensor> </Config> ``` 2. **校验机制** 工具会检测： - XML 标签闭合完整性 - 寄存器地址是否为十六进制 - 数值范围有效性（如超出 0x00-0xFF 报错） ### 五、常见错误处理 | 错误码 | 原因 | 解决方案 | |--------|---------------------|------------------------| | `ERR 0x101` | XML 语法错误 | 用 `xmllint` 校验格式 | | `ERR 0x205` | 寄存器地址冲突 | 检查重复的 addr 属性 | | `ERR 0x310` | 不支持的芯片型号 | 确认 `-m` 参数拼写正确 | ### 六、调试建议 1. 生成 Debug 日志： ```bash ./xml2bin -i cfg.xml -o out.bin --debug > log.txt ``` 2. 用 `hexdump` 解析输出： ```bash hexdump -C out.bin | less ``` > ⚠️ **重要提示**：若需要最新版工具，需升级 SDK 至 `V2.0+` 版本（旧版存在 64 位系统兼容性问题）[^2] ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值