试比较GD32E230系列与L233/235芯片在IIC上使用温度传感器SHT40的异同

最新推荐文章于 2024-07-11 14:14:38 发布
最新推荐文章于 2024-07-11 14:14:38 发布
阅读量155 收藏
点赞数 4
文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/teleger/article/details/139420031
版权

不说废话，上代码，不同之处直接用宏 展开

1. 首先是i2c 时钟配置  函数有些出入

void sensirion_i2c_attribute_config(){
    #ifdef GD32E230
    /* I2C clock configure */
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* I2C address configure */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_OWN_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
    #endif

    #ifdef GD32L235
    /* configure I2C timing */
    i2c_timing_config(I2C0, 0, 0x3, 0);
    i2c_master_clock_config(I2C0, 0x13, 0x36);
    i2c_address_config(I2C0, I2C1_OWN_ADDRESS7, I2C_ADDFORMAT_7BITS);
    /* configure slave address */
    //i2c_master_addressing(I2C0, 0x82, I2C_MASTER_TRANSMIT);
    /* enable I2C0 */
    i2c_enable(I2C0);
    #endif
}

2. 然后是 i2c 的读与 写，请看

a. 读

uint8_t sensirion_i2c_ReadByte_timeout(uint8_t Addr,uint8_t *data,uint16_t count){
    // IMPLEMENT
    #ifdef GD32E230
    uint8_t     state = I2C_START;
    uint16_t    timeout = 0;
    uint8_t     i2c_timeout_flag = 0;
    i2c_ackpos_config(I2C1, I2C_ACKPOS_NEXT);
    while(!(i2c_timeout_flag)){
        switch (state)
        {
        case I2C_START:
            while(i2c_flag_get(I2CX, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_start_on_bus(I2C1);//i2c_start
                timeout = 0;
                state = I2C_SEND_ADDRESS;
            }else{
                timeout = 0;
                state = I2C_START;
                //PR_DEBUG("i2c bus is busy in byte read \r\n");
            }
            break;
        case I2C_SEND_ADDRESS:
            /* i2c master sends START signal successfully */
            while((!i2c_flag_get(I2CX, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_master_addressing(I2CX, (Addr << 1), I2C_RECEIVER);
                timeout = 0;
                state = I2C_CLEAR_ADDRESS_FLAG;
            }else{
                timeout = 0;
                state = I2C_START;
                //add //提前退出循环
                i2c_timeout_flag = I2C_OK;
                //PR_DEBUG("i2c master sends start signal timeout in BYTE READ!\n");
            }
            break;
        case I2C_CLEAR_ADDRESS_FLAG:
            /* address flag set means i2c slave sends ACK */
            while((!i2c_flag_get(I2CX, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_flag_clear(I2CX, I2C_FLAG_ADDSEND);
                timeout = 0;
                state = I2C_TRANSMIT_DATA;
            }else{
                timeout = 0;
                state = I2C_START;
                //add //提前退出循环
                i2c_timeout_flag = I2C_OK;
                //PR_DEBUG("i2c master clears address flag timeout in BYTE WRITE!\n");
            }
            break;
        case I2C_TRANSMIT_DATA:
             /* wait until the transmit data buffer is empty */
            while((!i2c_flag_get(I2CX, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            while(count){
                if(count == 1){
                    i2c_ackpos_config(I2C1, I2C_ACKPOS_CURRENT);
                    i2c_ack_config(I2C1, I2C_ACK_DISABLE);
                }
                if(i2c_flag_get(I2C1, I2C_FLAG_RBNE)){
                    *data = i2c_data_receive(I2C1);
                    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
                    data++;
                    count--;
                }else{
                    state = I2C_START;
                    timeout = 0;
                }
            }
            state = I2C_STOP;
            timeout = 0;
            break;
        case I2C_STOP:
            /* send a stop condition to I2C bus */
            i2c_stop_on_bus(I2CX);
            /* i2c master sends STOP signal successfully */
            while((I2C_CTL1(I2CX) & 0x0200) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_ackpos_config(I2C1, I2C_ACKPOS_CURRENT);
                /* enable acknowledge */
                i2c_ack_config(I2C1, I2C_ACK_ENABLE);
                
                timeout = 0;
                state = I2C_END;
                i2c_timeout_flag = I2C_OK;
            }else{
                timeout = 0;
                state = I2C_START;
                //PR_DEBUG("i2c master sends stop signal timeout in BYTE READ\n");
            }
            break;
        default:
            state = I2C_START;
            i2c_timeout_flag = I2C_OK;
            timeout = 0;
            //PR_DEBUG("i2c master sends start signal in BYTE READ!\n");
            break;
        }
    }
    #endif

    #ifdef GD32L235
    i2c_process_enum    state = I2C_START;
    uint32_t            timeout = 0;
    uint8_t             end_flag = 0;
    //i2c_nack_disable(I2CX);
    i2c_transfer_byte_number_config(I2CX, count);
#if 1
    i2c_reload_disable(I2CX);
    /* enable I2C automatic end mode in master mode */
    i2c_automatic_end_enable(I2CX);
#endif

    while(!(end_flag))
    {
        //printf("i2c bus is busy in read_state:%d,LINE: %d!\r\n",state,__LINE__);
        switch (state)
        {
        case I2C_START:
            /* configure number of bytes to be transferred */
            while(i2c_flag_get(I2CX, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) 
            {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_start_on_bus(I2CX);
                timeout = 0;
                state = I2C_SEND_ADDRESS;
            } else {
                /* timeout, bus reset */
                //i2c_bus_reset();
                timeout = 0;
                state = I2C_START;
                end_flag = I2C_OK;
                printf("i2c bus is busy in read_%d!\r\n",__LINE__);
            }
            break;
        case I2C_SEND_ADDRESS:
            while((!i2c_flag_get(I2CX, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_master_addressing(I2CX, (Addr<<1), I2C_MASTER_RECEIVE);
                state = I2C_TRANSMIT_DATA;
            }else{
                timeout = 0;
                state = I2C_START;
                end_flag = I2C_OK;
                printf("i2c bus is I2C_SEND_ADDRESS timeout:%d!\r\n",__LINE__);
            }
            break;
        case I2C_TRANSMIT_DATA:
            while(count)
            {
                if(i2c_flag_get(I2CX, I2C_FLAG_RBNE)){
                    *data = i2c_data_receive(I2CX);
                    data++;
                    count--;
                }
            }
            state = I2C_STOP;
            timeout = 0;
            //printf("i2c transmit complete %d \r\n",i2c_flag_get(I2CX, I2C_FLAG_RBNE));
            break;
        case I2C_STOP:
            /* wait until the stop condition is finished */
            while((!i2c_flag_get(I2CX, I2C_FLAG_STPDET)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                /* clear STPDET flag */
                i2c_flag_clear(I2CX, I2C_FLAG_STPDET);
                timeout = 0;
                state = I2C_END;
                end_flag = I2C_OK;
            } else {
                timeout = 0;
                state = I2C_START;
                //printf("i2c master sends stop signal timeout in read!\n");
            }
            break;
        default:
            /* default status */
            state = I2C_START;
            end_flag = 1;
            timeout = 0;
            printf("i2c master sends start signal in read!\n");
            break;
        }
    }
    #endif
    return state;
}

b. 写

uint8_t sensirion_i2c_WriteByte_timeout(uint8_t Addr,const uint8_t *data,uint16_t count){
    #ifdef  GD32E230
    uint8_t     state = I2C_START;
    uint16_t    timeout = 0;
    uint8_t     i2c_timeout_flag = 0;
    while(!(i2c_timeout_flag)){
        switch (state)
        {
        case I2C_START:
            while(i2c_flag_get(I2C1, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_start_on_bus(I2C1);//i2c_start
                timeout = 0;
                state = I2C_SEND_ADDRESS;
            }else{
                timeout = 0;
                state = I2C_START;
                i2c_timeout_flag = I2C_OK;
                //PR_ERR("%s,i2c bus is busy in byte write \r\n",SENSIR_STR);
            }
            break;
        case I2C_SEND_ADDRESS:
            /* i2c master sends START signal successfully */
            while((!i2c_flag_get(I2CX, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_master_addressing(I2CX, (Addr << 1), I2C_TRANSMITTER);
                timeout = 0;
                state = I2C_CLEAR_ADDRESS_FLAG;
            }else{
                timeout = 0;
                state = I2C_START;
                i2c_timeout_flag = I2C_OK;
                //PR_ERR("%s,i2c master sends start signal timeout in BYTE WRITE!\r\n",SENSIR_STR);
            }
            break;
        case I2C_CLEAR_ADDRESS_FLAG:
            /* address flag set means i2c slave sends ACK */
            while((!i2c_flag_get(I2CX, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                i2c_flag_clear(I2CX, I2C_FLAG_ADDSEND);
                timeout = 0;
                state = I2C_TRANSMIT_DATA;
            }else{
                timeout = 0;
                state = I2C_START;
                //add 提前退出循环
                i2c_timeout_flag = I2C_OK;
                //PR_ERR("%s,i2c master clears address flag timeout in BYTE WRITE!\r\n",SENSIR_STR);
            }
            break;
        case I2C_TRANSMIT_DATA:
            /* wait until the transmit data buffer is empty */
            while((!i2c_flag_get(I2CX, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }

            while(count)
            {
                i2c_data_transmit(I2CX, *data);
                data++;
                count--;
                while((!i2c_flag_get(I2CX, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)){
                    timeout++;
                }
                if(timeout < I2C_TIME_OUT){
                    timeout = 0;
                }else{
                    timeout = 0;
                    state = I2C_START;
                    i2c_timeout_flag = I2C_OK;
                    //PR_ERR("%s,i2c master sends data timeout in PAGE WRITE!\n",SENSIR_STR);
                    break;
                }
            }
            state = I2C_STOP;
            timeout = 0;
            break;
        case I2C_STOP:
            /* send a stop condition to I2C bus */
            i2c_stop_on_bus(I2CX);
            /* i2c master sends STOP signal successfully */
            while((I2C_CTL1(I2CX) & 0x0200) && (timeout < I2C_TIME_OUT)){
                timeout++;
            }
            if(timeout < I2C_TIME_OUT){
                timeout = 0;
                state = I2C_END;
                i2c_timeout_flag = I2C_OK;
            }else{
                timeout = 0;
                state = I2C_START;
                //PR_ERR("%s,i2c master sends stop signal timeout in BYTE WRITE\r\n",SENSIR_STR);
            }
            break;
        default:
            state = I2C_START;
            i2c_timeout_flag = I2C_OK;
            timeout = 0;
            //PR_DEBUG("%s,i2c master sends start signal in BYTE WRITE!\r\n",SENSIR_STR);
            break;
        }
    }
    #endif

    #ifdef GD32L235
    i2c_process_enum        state = I2C_START;
    uint16_t                timeout = 0;
    uint8_t                 end_flag = 0;
    i2c_transfer_byte_number_config(I2C0, 16);
    //printf("i2c_master_addressing:0x%x\r\n",Addr<<1);
    while(!(end_flag)){
        //printf("IIC writeByte,state: %d\r\n",state);
        switch(state){
            case I2C_START:
                while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)){
                    timeout++;
                }
                if(timeout < I2C_TIME_OUT){
                    i2c_start_on_bus(I2C0);
                    timeout = 0;
                    state = I2C_SEND_ADDRESS;
                }else{
                    timeout = 0;
                    state = I2C_START;
                    end_flag = I2C_OK;
                    //printf("i2c bus is busy in  writeByte! %d\r\n",__LINE__);
                }
                break;
            case I2C_SEND_ADDRESS:
                while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)){
                    timeout++;
                }
                if(timeout < I2C_TIME_OUT){
                    timeout = 0;
                    i2c_master_addressing(I2C0, Addr<<1, I2C_MASTER_TRANSMIT);
                    state = I2C_TRANSMIT_DATA;
                }else{
                    timeout = 0;
                    state = I2C_START;
                    //printf("i2c master sends 's internal address timeout in  writeByte!\r\n");
                }
                break;
            case I2C_TRANSMIT_DATA:
                while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)){
                    timeout++;
                }
                if(timeout < I2C_TIME_OUT){
                    timeout = 0;
                    i2c_data_transmit(I2C0, *data);
                    state = I2C_STOP;
                }else{
                    timeout = 0;
                    state = I2C_START;
                    //printf("i2c master sends data timeout in  writeByte! \r\n");
                }
                //printf("i2c_step2 NCK:%d! \r\n",i2c_flag_get(I2C0, I2C_FLAG_NACK));
                break;
            case I2C_STOP:
                /* send a stop condition to I2C bus */
                i2c_stop_on_bus(I2C0);
                /* i2c master sends STOP signal successfully */
                while(!i2c_flag_get(I2C0, I2C_FLAG_STPDET) && (timeout < I2C_TIME_OUT)){
                    timeout++;
                }
                if(timeout < I2C_TIME_OUT){
                    timeout = 0;
                    state = I2C_END;
                    end_flag = I2C_OK;
                    /* clear the STPDET bit */
                    i2c_flag_clear(I2C0, I2C_FLAG_STPDET);
                }else{
                    timeout = 0;
                    state   = I2C_START;
                    printf("i2c master sends stop signal timeout in  writeByte!\r\n");
                }
                break;
        default:
            state = I2C_START;
            end_flag = I2C_OK;
            timeout = 0;
            printf("i2c master sends start signal in  WRITE!\r\n");
            break;
        }
    }
    #endif
    return state;
}

因为 两套api 接口不一致，所以还是有较大出入的。希望 在用这款单片机的兄弟闷，少走弯路，我这已经调好，拿走不谢！

Teleger
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
GD32E230系列资料.rar
08-10
GD32E230系列是GD32微控制器家族中的一个成员，专注于提供高性能、低功耗的解决方案。这个系列的芯片适用于各种嵌入式应用，如物联网设备、智能家居、工业控制等。该压缩包文件包含了一系列关于GD32E230的重要资源，...
GD32E230硬件IIC读写24C04
06-08
标题中的“GD32E230硬件IIC读写24C04”涉及到的是在GD32E230系列微控制器上通过硬件IIC接口与24C04 EEPROM进行通信的过程。GD32E230是GD32微控制器家族中的一员，基于ARM Cortex-M23内核，具有高效能和低功耗的特点...
【GD32L233C-START】6、硬件I2C驱动0.96吋OLED
freemote的博客
02-15 1709
​ 1、关于GD32L233CCT6的I2C接口 可以看出有两路I2C，分别是I2C0，I2C1。 2、开发板上I2C的引脚 可以看出，I2C1的引脚为PB10和PB11。 3、通用引脚复用为I2C 可以看出，是复用功能4。 4、代码实现 （1）初始化i2c void I2cInit(void) { rcu_periph_clock_enable(RCU_I2C1); rcu_periph_clock_enable(RCU_GPIOB); gpio_af_set(GPIOB, GPIO_AF_
GD32L233X 硬件I2C读取BQ40Z50的配置
yybyg的博客
11-09 1103
最近用GDL233标准库来对BQ40Z50进行I2C通讯，真的是一堆坑，官方的例程有用但不全，好险有逻辑分析仪，要不然一周都搞不定这玩意。
GD32硬件I2C外设详解
zdlzf的博客
10-31 1501
I2C总线是PHLIPS公司推出的一种双线式半双工串行总线，是具备多主机系统所需的总线裁决和高低速器件同步功能的高性能串行总线。用于连接微控器及外围设备。I2C总线只有两根双向信号线。一根是数据线SDA，另一根是时钟线SCL。通用的I2C总线，可以使各种设备的通信标准统一，对于厂家来说，使用成熟的方案可以缩短芯片设计周期、提高稳定性，对于应用者来说，使用通用的通信协议可以避免学习各种各样的自定义协议，降低了学习和应用的难度；
【GD32L233C-START】1、初识GD32L233C-START板卡
freemote的博客
02-08 3996
1、GD32L233x系列mcu Arm® Cortex®-M23内核，最高主频为64MHz； 集成了64KB到256KB的嵌入式eFlash和16KB到32KB的SRAM； 深度睡眠（Deep-sleep）电流降至2uA，唤醒时间低于10uS； 待机（Standby）电流最低仅有0.4uA； 深度睡眠模式下能够被多种系统时钟、外设接口触发，支持Low power Timer、Low power UART、RTC、LCD以及标准I2C、USART等在内的多个唤醒源； 芯片供电电压为1.7-3.6V，并支持
使用GD32内嵌IIC控制器
kaizq的专栏
07-25 2967
1 综述 采用GD32内嵌IIC控制器，以中断方式，快速实现的IIC通信，速度400kbps。 IIC通信，诸如常用的STM32，多是用IO口模拟IIC通信的。曾经以STM32内嵌IIC控制器，以中断方式，快速实现了IIC通信。实现的关键是1字节的读取操作。 作为后起之秀，GD对IIC控制器逻辑改进了很多，已经很好用。 美中不足，1字节的读取，却多操作了1个字节，始终没有找到最合适的STOP发出时刻，好在不影响使用。即：1字节的读取，需要多作1字节的无用功。该问题，在STM32中，已经完美解决。
【基于GD32E230的定时器级联M/T法电机测速】
dy_ngmm的博客
06-02 2385
本文主要是使用GD32E230单片机的定时器级联，使用M/T法捕获带增量编码器电机的旋转速度。
【国货之光】GD32E230F4使用硬件IIC+DMA读写24C04
ic2121的博客
10-19 1825
上面的GPIO的初始化一般没什么好说的，IO设置为开漏输出模式，因为IIC总线有读和写两个操作，开漏是最好的，这里说的是最好，其实设置为推挽输出也是可以的，这里有必要提一下，因为上周在论坛看到有的兄弟在调试SPI时，拿到的例程，GPIO设置为推挽输出，导致很疑惑，设置为输出如何去读SPI的数据。果然，已经快要顶不住了，于是果断修改keil的编译优化选项，将优化等级提升为1级，内存缩小很多，问题便可解除，因为之前没用过这么下的MCU，而且这次编译没报错，若不是上次报错让我找到原因，这次不知又要卡多久。
GD32E230_GPIO_IC模拟GPIO.rar
07-12
"GD32E230_GPIO_EEPROM"可能是一个示例程序或库，展示了如何在GD32E230上通过GPIO模拟IIC与EEPROM（电可擦可编程只读存储器）设备进行通信。EEPROM常用于存储非易失性数据，如配置参数、固件更新等。在模拟IIC通信中...
Giga_Device_GD32E230_Pack.zip
05-12
《GD32E230微控制器在Keil IDE中的应用与开发详解》 GD32E230系列是GigaDevice公司推出的一款高性能、低功耗的32位微控制器，它基于ARM Cortex-M23内核，广泛应用于嵌入式系统设计。这个名为“Giga_Device_GD32E230...
GD32E230_Firmware_Library_V1.0.0.rar_GD32E230固件_GD32标准库下载_gd32e2
09-21
GD32E230标准固件库。适用于GD32E230系列MCU，与Cortex-M微控制器软件接口标准(CMSIS)兼容。固件库包括程序、数据结构和宏定义，覆盖所有集成外设的特征，并包括了全部相关驱动和示例程序。
【在线词典】项目实现
2201_75563094的博客
07-08 1019
C语言 SQLite3数据库 UDP通信 实现在线词典
使用定时器消除抖动
m0_47239466的博客
07-09 143
具体怎么实现
IAR全面支持芯驰科技E3系列车规MCU产品E3119/E3118
最新发布
mahuahu的博客
07-11 773
全球领先的嵌入式系统开发软件解决方案供应商IAR与全场景智能车芯引领者芯驰科技宣布进一步扩大合作，最新版IAR Embedded Workbench for Arm已全面支持芯驰科技的E3119/E3118车规级MCU产品。IAR与芯驰科技有着悠久的合作历史，此次双方在车规功能安全领域强强联合，将为行业带来更高效、更安全的解决方案。
STM32学习历程（day5）
weixin_60039521的博客
07-09 334
今天学习了OLED屏幕的用法 但是up主是直接给的程序 代码比较繁多 演示了下如何通过OLED调试程序 以及使用断点等、然后就学了EXTI外部中断 以前学习的时候 是通过汇编来学习的 算是了解一点 汇编在这块得自己保存CPU运行时的地址 以及保存现场 恢复现场。但是通过C语言就不要了 编译器都给我们处理好了。
单片机学习（17）--AD/DA
LHYYUYG的博客
07-08 922
AD(AnalogtoDigital)：模拟-数字转换，将模拟信号转换为计算机可操作的数字信号DA(DigitaltoAnalog)：数字-模拟转换，将计算机输出的数字信号转换为模拟信号AD/DA转换打开了计算机与模拟信号的大门，极大的提高了计算机系统的应用范围，也为模拟信号数字化处理提供了可能。
gd32e230 iic
09-13
你想了解关于GD32E230芯片的IIC（I2C）接口吗？IIC是一种串行通信协议，用于连接微控制器和外部设备，可以实现多个设备之间的数据传输。GD32E230是一款由GigaDevice公司生产的低功耗ARM Cortex-M0+内核的微控制器芯片。它具有丰富的外设和多个通信接口，包括IIC接口。 要在GD32E230中使用IIC接口，您需要配置相关的引脚和寄存器。首先，您需要选择适当的引脚作为IIC接口的时钟线（SCL）和数据线（SDA）。然后，您需要配置相应的寄存器来设置IIC的工作模式、速率等参数。 在编程方面，您可以使用相应的库函数或驱动程序来控制IIC接口。这些库函数通常提供了发送和接收数据的功能，以及设置地址、读取状态等功能。您可以根据您的具体需求来选择适合您的开发环境和应用需求的库函数。 请注意，详细的配置和使用方法可能因具体的开发环境和使用的库函数而有所不同。因此，您可以参考GD32E230的官方文档、相关的开发工具文档或用户指南来获取更详细的信息和示例代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Teleger

你的支持是我前进的方向

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值