10 软件iic的初始化需要调用哪些函数？

发布于 2022-07-20 14:51:26 浏览：1062 订阅该版

使用模拟iic读写铁电，初始化如下：
```c
void fm24c64_init(void)
{
	 i2c_bus_eeprom = (struct rt_i2c_bus_device *)rt_device_find(EE_DEVICE_NAME);
		 i2c_bus_eeprom = rt_i2c_bus_device_find(EE_DEVICE_NAME);
	if (RT_NULL == i2c_bus_eeprom) rt_pin_write(GET_PIN(C, 1), PIN_LOW);
//	rt_i2c_bus_device_register(i2c_bus_eeprom, EE_DEVICE_NAME);
}
```
串口是find，open就行。这个iic我看官网文档，find就可以，也没有注册函数，它怎么知道我使用的是PB8 PB9呢？现在通信不成功，想找找是不是初始化的问题，谢谢
我想通信成功，还应该怎么初始化呢？上面注册注释掉，是因为如果不注释掉，程序会卡在RT_ASSERT里。
谢谢

![screenshot_图片.png](https://oss-club.rt-thread.org/uploads/20220720/deec229466c3a4834c71a7a50f0b4dc7.png)

![screenshot_图片.png](https://oss-club.rt-thread.org/uploads/20220720/3b32515586b3526f07a4a35d441c25e0.png)

读写函数是从论坛抄的
```c
rt_err_t eeprom_write(rt_uint16_t addr, uint8_t *buf, rt_uint32_t len)
{
    rt_size_t size;
    rt_uint8_t addr_buf[2];
    rt_uint32_t wrlen;
    do {
        wrlen = EE_PAGESIZE - addr % EE_PAGESIZE;
        if (wrlen > len) wrlen = len;
//        rt_kprintf("addr=%d, wrlen=%d\n", addr, wrlen); //DEBUG
        addr_buf[0] = (addr>>8)&0xFF;
        addr_buf[1] = addr & 0xFF;
        size = rt_i2c_master_send(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_WR|RT_I2C_NO_STOP, addr_buf, 2); /* fixed: no stop iic */
        if (size != 2) {
//            rt_kprintf("RD1.EEPROM write failed, size is:%d\n", size);
            return -RT_ERROR;
        }
#if 0
        //DEBUG
        for(int i=0; i<wrlen; i++) {
            rt_kprintf("%c ", *(char*)(buf+i));
        }
        rt_kprintf("\n");
#endif
        size = rt_i2c_master_send(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_WR|RT_I2C_NO_START, buf, wrlen); /* fixed: no restart iic */
        if (size != wrlen) {
            rt_kprintf("WR1.EEPROM write failed, addr:%02X%02X, size=%d\n", addr_buf[0], addr_buf[1], size);
            return -RT_ERROR;
        }
        buf  += wrlen; //change to next page data align to EE_PAGESIZE bytes.
        addr += wrlen; //change to next page address.
        len  -= wrlen;
        rt_thread_mdelay(5);//根据器件手册设置延时
    } while (len);
    return RT_EOK;
}

rt_err_t eeprom_read(rt_uint16_t addr, uint8_t *buf, rt_uint32_t len)
{
    rt_size_t size;
    rt_uint8_t addr_buf[2];
    addr_buf[0] = (addr>>8)&0xFF;
    addr_buf[1] = addr & 0xFF;
    size = rt_i2c_master_send(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_WR, addr_buf, 2);
    if (size != 2) {
        rt_kprintf("RD1.EEPROM write failed, size is:%d\n", size);
        return -RT_ERROR;
    }
    size = rt_i2c_master_recv(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_RD, buf, len);
    if (size != len) {
        rt_kprintf("RD2.EEPROM write failed, size is:%d\n", size);
        return -RT_ERROR;
    }
    return RT_EOK;
}
```

crystal266 2022-07-20

嵌入式

1 RT-Thread 自带的有 AT24Cxx eeprom 的驱动库，不知道你用的是不是这个系列的芯片，如果是的话可以直接使用官方带的软件包，就不用自己来写驱动函数了。使用 at24cxx 软件包需要在 RT-Thread 的包管理器中(或者 env 工具中)选择它，具体路径如下：
```c
RT-Thread online packages
    peripheral libraries and drivers  --->
        [*] at24cxx: eeprom at24cxx driver library  --->
            Version (latest)  --->
```

2 如果是自己写驱动函数的话，只需要 find 一下就行了，前提是需要在 board.h 中指定要使用的 IIC引脚，如下所示。
```c
#define BSP_USING_I2C1      // 片外 RTC
#ifdef BSP_USING_I2C1
#define BSP_I2C1_SCL_PIN    GET_PIN(B, 8)
#define BSP_I2C1_SDA_PIN    GET_PIN(B, 9)
#endif
```

串口需要调用 open 是因为，调用 open 之后就会去初始化串口的引脚（即将对应的引脚功能复用为串口功能），软件 IIC 不用调用 open 是因为他是用 GPIO 模拟的，所以无需将引脚复用为 IIC 的功能，在使用的时候直接操作 GPIO 引脚的电平来模拟 IIC 的时序，在文件 drv_soft_i2c.c 中对相应的模拟 IIC 的引脚进行了初始化的操作，相关代码如下：
```c
/**
 * This function initializes the i2c pin.
 *
 * @param Stm32 i2c dirver class.
 */
static void stm32_i2c_gpio_init(struct stm32_i2c *i2c)
{
    struct stm32_soft_i2c_config* cfg = (struct stm32_soft_i2c_config*)i2c->ops.data;

rt_pin_mode(cfg->scl, PIN_MODE_OUTPUT_OD);
    rt_pin_mode(cfg->sda, PIN_MODE_OUTPUT_OD);

rt_pin_write(cfg->scl, PIN_HIGH);
    rt_pin_write(cfg->sda, PIN_HIGH);
}

/* I2C initialization function */
int rt_hw_i2c_init(void)
{
    rt_size_t obj_num = sizeof(i2c_obj) / sizeof(struct stm32_i2c);
    rt_err_t result;

for (int i = 0; i < obj_num; i++)
    {
        i2c_obj[i].ops = stm32_bit_ops_default;
        i2c_obj[i].ops.data = (void*)&soft_i2c_config[i];
        i2c_obj[i].i2c2_bus.priv = &i2c_obj[i].ops;
        stm32_i2c_gpio_init(&i2c_obj[i]);
        result = rt_i2c_bit_add_bus(&i2c_obj[i].i2c2_bus, soft_i2c_config[i].bus_name);
        RT_ASSERT(result == RT_EOK);
        stm32_i2c_bus_unlock(&soft_i2c_config[i]);
        
        LOG_D("software simulation %s init done, pin scl: %d, pin sda %d",
        soft_i2c_config[i].bus_name, 
        soft_i2c_config[i].scl, 
        soft_i2c_config[i].sda);
    }

return RT_EOK;
}
INIT_BOARD_EXPORT(rt_hw_i2c_init);
```

crystal266 2022-07-20

嵌入式

at24cxx eeprom 的读写示例也可以参考链接
  1 [RT-Thread使用I2C读写eeprom例程（24c02）](https://blog.csdn.net/yang1111111112/article/details/83276512 "RT-Thread使用I2C读写eeprom例程（24c02）")
  2 [RT Thread Studio实战——AT24C32的使用](https://blog.csdn.net/WangShiRuManWoRuLi/article/details/116085363 "RT Thread Studio实战——AT24C32的使用")

官方软件包的使用方法参考链接  [AT24CXX 软件包
](https://packages.rt-thread.org/detail.html?package=at24cxx) 其中引脚号的定义在文件 `drivers/drv_gpio.c` 中，示例如下（需要按照自己的芯片型号查看该文件进行修改）。例如你 IIC_SCL 的引脚是 PA11，IIC_SDA 的引脚是 PC2，根据下面的代码找到对应的引脚号分别为 11 和 34
```c
static const struct pin_index pins[] = 
{
#if defined(GPIOA)
    __STM32_PIN(0 ,  A, 0 ),
    __STM32_PIN(1 ,  A, 1 ),
    __STM32_PIN(2 ,  A, 2 ),
    __STM32_PIN(3 ,  A, 3 ),
    __STM32_PIN(4 ,  A, 4 ),
    __STM32_PIN(5 ,  A, 5 ),
    __STM32_PIN(6 ,  A, 6 ),
    __STM32_PIN(7 ,  A, 7 ),
    __STM32_PIN(8 ,  A, 8 ),
    __STM32_PIN(9 ,  A, 9 ),
    __STM32_PIN(10,  A, 10),
    __STM32_PIN(11,  A, 11),
    __STM32_PIN(12,  A, 12),
    __STM32_PIN(13,  A, 13),
    __STM32_PIN(14,  A, 14),
    __STM32_PIN(15,  A, 15),
#if defined(GPIOB)
    __STM32_PIN(16,  B, 0),
    __STM32_PIN(17,  B, 1),
    __STM32_PIN(18,  B, 2),
    __STM32_PIN(19,  B, 3),
    __STM32_PIN(20,  B, 4),
    __STM32_PIN(21,  B, 5),
    __STM32_PIN(22,  B, 6),
    __STM32_PIN(23,  B, 7),
    __STM32_PIN(24,  B, 8),
    __STM32_PIN(25,  B, 9),
    __STM32_PIN(26,  B, 10),
    __STM32_PIN(27,  B, 11),
    __STM32_PIN(28,  B, 12),
    __STM32_PIN(29,  B, 13),
    __STM32_PIN(30,  B, 14),
    __STM32_PIN(31,  B, 15),
#if defined(GPIOC)
    __STM32_PIN(32,  C, 0),
    __STM32_PIN(33,  C, 1),
    __STM32_PIN(34,  C, 2),
    __STM32_PIN(35,  C, 3),
    __STM32_PIN(36,  C, 4),
    __STM32_PIN(37,  C, 5),
    __STM32_PIN(38,  C, 6),
    __STM32_PIN(39,  C, 7),
    __STM32_PIN(40,  C, 8),
    __STM32_PIN(41,  C, 9),
    __STM32_PIN(42,  C, 10),
    __STM32_PIN(43,  C, 11),
    __STM32_PIN(44,  C, 12),
    __STM32_PIN(45,  C, 13),
    __STM32_PIN(46,  C, 14),
    __STM32_PIN(47,  C, 15),
#if defined(GPIOD)
    __STM32_PIN(48,  D, 0),
    __STM32_PIN(49,  D, 1),
    __STM32_PIN(50,  D, 2),
    __STM32_PIN(51,  D, 3),
    __STM32_PIN(52,  D, 4),
    __STM32_PIN(53,  D, 5),
    __STM32_PIN(54,  D, 6),
    __STM32_PIN(55,  D, 7),
    __STM32_PIN(56,  D, 8),
    __STM32_PIN(57,  D, 9),
    __STM32_PIN(58,  D, 10),
    __STM32_PIN(59,  D, 11),
    __STM32_PIN(60,  D, 12),
    __STM32_PIN(61,  D, 13),
    __STM32_PIN(62,  D, 14),
    __STM32_PIN(63,  D, 15),
#if defined(GPIOE)
    __STM32_PIN(64,  E, 0),
    __STM32_PIN(65,  E, 1),
    __STM32_PIN(66,  E, 2),
    __STM32_PIN(67,  E, 3),
    __STM32_PIN(68,  E, 4),
    __STM32_PIN(69,  E, 5),
    __STM32_PIN(70,  E, 6),
    __STM32_PIN(71,  E, 7),
    __STM32_PIN(72,  E, 8),
    __STM32_PIN(73,  E, 9),
    __STM32_PIN(74,  E, 10),
    __STM32_PIN(75,  E, 11),
    __STM32_PIN(76,  E, 12),
    __STM32_PIN(77,  E, 13),
    __STM32_PIN(78,  E, 14),
    __STM32_PIN(79,  E, 15),
#if defined(GPIOF)
    __STM32_PIN(80,  F, 0),
    __STM32_PIN(81,  F, 1),
    __STM32_PIN(82,  F, 2),
    __STM32_PIN(83,  F, 3),
    __STM32_PIN(84,  F, 4),
    __STM32_PIN(85,  F, 5),
    __STM32_PIN(86,  F, 6),
    __STM32_PIN(87,  F, 7),
    __STM32_PIN(88,  F, 8),
    __STM32_PIN(89,  F, 9),
    __STM32_PIN(90,  F, 10),
    __STM32_PIN(91,  F, 11),
    __STM32_PIN(92,  F, 12),
    __STM32_PIN(93,  F, 13),
    __STM32_PIN(94,  F, 14),
    __STM32_PIN(95,  F, 15),
#if defined(GPIOG)
    __STM32_PIN(96,  G, 0),
    __STM32_PIN(97,  G, 1),
    __STM32_PIN(98,  G, 2),
    __STM32_PIN(99,  G, 3),
    __STM32_PIN(100, G, 4),
    __STM32_PIN(101, G, 5),
    __STM32_PIN(102, G, 6),
    __STM32_PIN(103, G, 7),
    __STM32_PIN(104, G, 8),
    __STM32_PIN(105, G, 9),
    __STM32_PIN(106, G, 10),
    __STM32_PIN(107, G, 11),
    __STM32_PIN(108, G, 12),
    __STM32_PIN(109, G, 13),
    __STM32_PIN(110, G, 14),
    __STM32_PIN(111, G, 15),
#if defined(GPIOH)
    __STM32_PIN(112, H, 0),
    __STM32_PIN(113, H, 1),
    __STM32_PIN(114, H, 2),
    __STM32_PIN(115, H, 3),
    __STM32_PIN(116, H, 4),
    __STM32_PIN(117, H, 5),
    __STM32_PIN(118, H, 6),
    __STM32_PIN(119, H, 7),
    __STM32_PIN(120, H, 8),
    __STM32_PIN(121, H, 9),
    __STM32_PIN(122, H, 10),
    __STM32_PIN(123, H, 11),
    __STM32_PIN(124, H, 12),
    __STM32_PIN(125, H, 13),
    __STM32_PIN(126, H, 14),
    __STM32_PIN(127, H, 15),
#if defined(GPIOI)
    __STM32_PIN(128, I, 0),
    __STM32_PIN(129, I, 1),
    __STM32_PIN(130, I, 2),
    __STM32_PIN(131, I, 3),
    __STM32_PIN(132, I, 4),
    __STM32_PIN(133, I, 5),
    __STM32_PIN(134, I, 6),
    __STM32_PIN(135, I, 7),
    __STM32_PIN(136, I, 8),
    __STM32_PIN(137, I, 9),
    __STM32_PIN(138, I, 10),
    __STM32_PIN(139, I, 11),
    __STM32_PIN(140, I, 12),
    __STM32_PIN(141, I, 13),
    __STM32_PIN(142, I, 14),
    __STM32_PIN(143, I, 15),
#if defined(GPIOJ)
    __STM32_PIN(144, J, 0),
    __STM32_PIN(145, J, 1),
    __STM32_PIN(146, J, 2),
    __STM32_PIN(147, J, 3),
    __STM32_PIN(148, J, 4),
    __STM32_PIN(149, J, 5),
    __STM32_PIN(150, J, 6),
    __STM32_PIN(151, J, 7),
    __STM32_PIN(152, J, 8),
    __STM32_PIN(153, J, 9),
    __STM32_PIN(154, J, 10),
    __STM32_PIN(155, J, 11),
    __STM32_PIN(156, J, 12),
    __STM32_PIN(157, J, 13),
    __STM32_PIN(158, J, 14),
    __STM32_PIN(159, J, 15),
#if defined(GPIOK)
    __STM32_PIN(160, K, 0),
    __STM32_PIN(161, K, 1),
    __STM32_PIN(162, K, 2),
    __STM32_PIN(163, K, 3),
    __STM32_PIN(164, K, 4),
    __STM32_PIN(165, K, 5),
    __STM32_PIN(166, K, 6),
    __STM32_PIN(167, K, 7),
    __STM32_PIN(168, K, 8),
    __STM32_PIN(169, K, 9),
    __STM32_PIN(170, K, 10),
    __STM32_PIN(171, K, 11),
    __STM32_PIN(172, K, 12),
    __STM32_PIN(173, K, 13),
    __STM32_PIN(174, K, 14),
    __STM32_PIN(175, K, 15),
#endif /* defined(GPIOK) */
#endif /* defined(GPIOJ) */
#endif /* defined(GPIOI) */
#endif /* defined(GPIOH) */
#endif /* defined(GPIOG) */
#endif /* defined(GPIOF) */
#endif /* defined(GPIOE) */
#endif /* defined(GPIOD) */
#endif /* defined(GPIOC) */
#endif /* defined(GPIOB) */
#endif /* defined(GPIOA) */
};

```

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

crystal266 2022-07-20

嵌入式

crystal266 2022-07-20

嵌入式

@[伊森亨特](https://club.rt-thread.org/u/331ffb741bc91fb2 '伊森亨特')

IIC 协议的软件模拟实现在文件 rt-thread/components/drivers/i2c/i2c-bit-ops.c 中，里面实现了 IIC 的起始信号、停止信号、应答非应答信号和读写等操作。部分代码如下，你可以看一下该文件
```c
#define SDA_L(ops)          SET_SDA(ops, 0)
#define SDA_H(ops)          SET_SDA(ops, 1)
#define SCL_L(ops)          SET_SCL(ops, 0)

/**
 * release scl line, and wait scl line to high.
 */
static rt_err_t SCL_H(struct rt_i2c_bit_ops *ops)
{
    rt_tick_t start;

SET_SCL(ops, 1);

if (!ops->get_scl)
        goto done;

start = rt_tick_get();
    while (!GET_SCL(ops))
    {
        if ((rt_tick_get() - start) > ops->timeout)
            return -RT_ETIMEOUT;

i2c_delay2(ops); // 修改延时时间  2022-07-15 by liuzhijie
        //rt_thread_delay((ops->timeout + 1) >> 1);
    }
#ifdef RT_I2C_BITOPS_DEBUG
    if (rt_tick_get() != start)
    {
        LOG_D("wait %ld tick for SCL line to go high",
              rt_tick_get() - start);
    }
#endif

done:
    i2c_delay(ops);

return RT_EOK;
}

static void i2c_start(struct rt_i2c_bit_ops *ops)
{
#ifdef RT_I2C_BITOPS_DEBUG
    if (ops->get_scl && !GET_SCL(ops))
    {
        LOG_E("I2C bus error, SCL line low");
    }
    if (ops->get_sda && !GET_SDA(ops))
    {
        LOG_E("I2C bus error, SDA line low");
    }
#endif
    SDA_L(ops);
    i2c_delay(ops);
    SCL_L(ops);
}

static void i2c_restart(struct rt_i2c_bit_ops *ops)
{
    SDA_H(ops);
    SCL_H(ops);
    i2c_delay(ops);
    SDA_L(ops);
    i2c_delay(ops);
    SCL_L(ops);
}

static void i2c_stop(struct rt_i2c_bit_ops *ops)
{
    SDA_L(ops);
    i2c_delay(ops);
    SCL_H(ops);
    i2c_delay(ops);
    SDA_H(ops);
    i2c_delay2(ops);
}

rt_inline rt_bool_t i2c_waitack(struct rt_i2c_bit_ops *ops)
{
    rt_bool_t ack;

SDA_H(ops);
    i2c_delay(ops);

if (SCL_H(ops) < 0)
    {
        LOG_W("wait ack timeout");

return -RT_ETIMEOUT;
    }

ack = !GET_SDA(ops);    /* ACK : SDA pin is pulled low */
    LOG_D("%s", ack ? "ACK" : "NACK");

SCL_L(ops);

return ack;
}
```

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

crystal266 2022-07-20

嵌入式

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

crystal266 2022-07-20

嵌入式

crystal266 2022-07-20

嵌入式

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

crystal266 2022-07-20

嵌入式

伊森亨特 2022-07-20

这家伙很懒，什么也没写！

crystal266 2022-07-20

嵌入式

crystal266 2022-07-20

嵌入式

伊森亨特 2022-07-21

这家伙很懒，什么也没写！

crystal266 2022-07-21

嵌入式

伊森亨特 2022-07-21

这家伙很懒，什么也没写！

crystal266 2022-07-21

嵌入式

@[伊森亨特](https://club.rt-thread.org/u/331ffb741bc91fb2 '伊森亨特')

我没用过这个包，但是按照源码分析你直接不用管这个变量也行，直接使用 7bit 的从机地址。我自己写的片外RTC模块（IIC接口）的读写函数如下所示，你也可以分析下源码看看，或者先不管或上的那个值试一下看看行不行。
```c
/**
 * @brief  通过I2C总线往外部RTC写数据
 * @param  slave_addr 从机地址（7位的）
 * @param  reg_addr 要写入的寄存器的起始地址
 * @param  write_data 要写入的数据，不包含从机地址和寄存器地址
 * @param  write_len 要写入数据的长度
 * @return 成功返回0，失败返回-1
 */
int ext_rtc_i2c_write_buf(rt_uint8_t slave_addr, rt_uint8_t reg_addr, rt_uint8_t *write_data, rt_uint8_t write_len)
{
    rt_uint8_t i;
    rt_size_t ret;
    rt_uint8_t send_buf[16] = { 0 };
    rt_uint32_t send_buf_len;

send_buf[0] = reg_addr;         // 寄存器地址
    memcpy((char *) &(send_buf[1]), (char *) write_data, write_len);    // 有效数据，不能使用 strncpy，因为数据中有 0x00
    send_buf_len = write_len + 1;   // 长度包含寄存器地址和有效负载

for (i = 0; i < 10; ++i)
    {
        ret = rt_i2c_master_send(rtc_i2c_dev, slave_addr, RT_I2C_WR, send_buf, send_buf_len);   // 发送写数据的命令
        if (ret == send_buf_len)
        {
            break;  // 发送成功则退出循环
        }

if (i == 10 - 1) // 到达了重发次数的上限
        {
            return -1;
        }

rt_thread_mdelay(100);  // 发送无响应延时一会
    }

return 0;
}

/**
 * @brief  通过I2C总线从外部RTC读取数据
 * @param  slave_addr 从机地址（7位的）
 * @param  reg_addr 要读取的寄存器的起始地址
 * @param  read_data 存储读出来的数据，不包含从机地址和寄存器地址
 * @param  read_len 要读取数据的长度
 * @return 成功返回0，失败返回-1
 */
int ext_rtc_i2c_read_buf(rt_uint8_t slave_addr, rt_uint8_t reg_addr, rt_uint8_t *read_data, rt_uint8_t read_len)
{
    rt_uint8_t i;
    rt_size_t ret;

for (i = 0; i < 10; ++i)
    {
        ret = rt_i2c_master_send(rtc_i2c_dev, slave_addr, RT_I2C_WR, ®_addr, 1); // 先发送要读取的寄存器地址
        if (ret == 1)
        {
            break;  // 发送成功则退出循环
        }

if (i == 10 - 1) // 到达了重发次数的上限
        {
            return -1;
        }

rt_thread_mdelay(100);  // 发送无响应延时一会
    }

for (i = 0; i < 10; ++i)
    {
        ret = rt_i2c_master_recv(rtc_i2c_dev, slave_addr, RT_I2C_RD, read_data, read_len);  // 发送读取数据的命令
        if (ret == read_len)
        {
            break;  // 读取成功则退出循环
        }

if (i == 10 - 1) // 到达了重发次数的上限
        {
            return -1;
        }

rt_thread_mdelay(100);  // 发送无响应延时一会
    }

return 0;
}
```

伊森亨特 2022-07-21

这家伙很懒，什么也没写！

crystal266 2022-07-21

嵌入式

crystal266 2022-07-21

嵌入式

伊森亨特 2022-07-21

这家伙很懒，什么也没写！

crystal266 2022-07-21

嵌入式

crystal266 2022-07-21

嵌入式

伊森亨特 2022-07-21

这家伙很懒，什么也没写！

@[crystal266](https://club.rt-thread.org/u/be372ec5d4723d5d 'crystal266')
多谢耐心回复我的问题，放弃了。移植了3个别人的代码，不对，自己写的也不对，我改用之前裸机用的eeprom驱动了，找到了us延时函数。
这是我写的
```c
rt_err_t farm_write_one_byte(rt_uint16_t addr_to_wr,rt_uint8_t byte_to_wr)
{
	rt_size_t size;
	rt_uint8_t buf[3];
	
	
	buf[0] = (addr_to_wr>>8) & 0xFF;
	buf[1] = addr_to_wr & 0xFF;
	buf[2] = byte_to_wr;
	size = rt_i2c_master_send(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_WR, buf, 3); /* fixed: no stop iic */
	rt_thread_mdelay(5);
	if (size == 3)
	{
		return RT_EOK;
	}
	else
	{
		return -RT_ERROR;
	}
	
	
	
}

rt_uint8_t farm_read_one_byte(rt_uint16_t addr_to_rd)
{
	rt_uint8_t buf[2];
	rt_size_t size;
	rt_uint8_t recv_byte = 0;
	rt_uint8_t slave_addr = EEPROM_ADDR;
	buf[0] = (addr_to_rd>>8) & 0xFF;
	buf[1] = addr_to_rd & 0xFF;
	size = rt_i2c_master_send(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_NO_STOP|RT_I2C_WR, buf, 2); /* fixed: no stop iic */
	rt_thread_mdelay(5);

size = rt_i2c_master_recv(i2c_bus_eeprom, EEPROM_ADDR, RT_I2C_RD, &recv_byte, 1);

}
```