devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Clion开发STM32之I2C驱动(参考RT-Thread)_stm32驱动sht40( i2c )

作者：一键难忘520 | 2024-08-15 07:58:33

赞

踩

stm32驱动sht40( i2c )

说明

  1. 本章是根据RT-Thread源码中的I2C组件进行抽离，主要不习惯用RT-Thread
  2. 然后在结合at24cxx模块补充测试
  3. 也为了方便移植和独立于框架的限制。

正文

操作gpio部分

#ifndef STM32_F1XX_TEMPLATE_BSP_GPIO_H
#define STM32_F1XX_TEMPLATE_BSP_GPIO_H

#include "sys_core.h"

#define GPIO_A_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
#define GPIO_B_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
#define GPIO_C_CLK_ENABLE() __HAL_RCC_GPIOC_CLK_ENABLE()
#define GPIO_D_CLK_ENABLE() __HAL_RCC_GPIOD_CLK_ENABLE()
#define GPIO_E_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
#define GPIO_F_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE()
#define GPIO_G_CLK_ENABLE() __HAL_RCC_GPIOG_CLK_ENABLE()

#define gpio_init(port, pin, mode, pull, speed)\
            do{\
                __HAL_RCC_##port##_CLK_ENABLE();\
                GPIO_InitTypeDef cnf ={pin,mode,pull,speed};\
                HAL_GPIO_Init(port, &cnf);\
            }while(0)
#define pin_high(port, pin) HAL_GPIO_WritePin(port,pin,GPIO_PIN_SET)
#define pin_low(port, pin) HAL_GPIO_WritePin(port,pin,GPIO_PIN_RESET)
#define stm_pin_set(port, pin, value)  HAL_GPIO_WritePin(port,pin,value)
#define pin_read(port, pin) HAL_GPIO_ReadPin(port,pin)
#define pin_toggle(port, pin) HAL_GPIO_TogglePin(port,pin)
typedef enum {
    pin_mode_output,
    pin_mode_input,
    pin_mode_input_pull_up,
    pin_mode_input_pull_down,
    pin_mode_output_od
} pin_mode_type;

sys_force_static_inline void gpio_clk_enable(GPIO_TypeDef *port) {
    if (port == GPIOA)GPIO_A_CLK_ENABLE();
    else if (port == GPIOB)GPIO_B_CLK_ENABLE();
    else if (port == GPIOC)GPIO_C_CLK_ENABLE();
    else if (port == GPIOD)GPIO_D_CLK_ENABLE();
    else if (port == GPIOE)GPIO_E_CLK_ENABLE();
    else if (port == GPIOF)GPIO_F_CLK_ENABLE();
    else if (port == GPIOG)GPIO_G_CLK_ENABLE();
}

sys_force_static_inline void stm32_pin_mode(GPIO_TypeDef *port, uint32_t pin, pin_mode_type mode) {
    GPIO_InitTypeDef GPIO_InitStruct = {
            .Pin = pin, .Mode = GPIO_MODE_OUTPUT_PP, .Speed = GPIO_SPEED_FREQ_HIGH, .Pull = GPIO_NOPULL};
    gpio_clk_enable(port);
    switch (mode) {

        case pin_mode_output: {
            /* output setting */
            GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
            break;
        }
        case pin_mode_input: {
            /* input setting: not pull. */
            GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
            break;
        }
        case pin_mode_input_pull_up: {
            /* input setting: pull up. */
            GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
            GPIO_InitStruct.Pull = GPIO_PULLUP;
            break;
        }
        case pin_mode_input_pull_down: {
            /* input setting: pull down. */
            GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
            GPIO_InitStruct.Pull = GPIO_PULLDOWN;
            break;
        }
        case pin_mode_output_od: {
            /* output setting: od. */
            GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
            break;
        }
    }
    HAL_GPIO_Init(port, &GPIO_InitStruct);
}

#endif //STM32_F1XX_TEMPLATE_BSP_GPIO_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
  • 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
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

头文件

#ifndef STM32_F1XX_TEMPLATE_BSP_I2C_SOFT_H
#define STM32_F1XX_TEMPLATE_BSP_I2C_SOFT_H

#include "bsp_include.h"

typedef struct {
    uint32_t scl;
    uint32_t sda;
    GPIO_TypeDef *port_scl;
    GPIO_TypeDef *port_sda;
} soft_i2c_cnf_t;
typedef struct {
    soft_i2c_cnf_t *cnf;/*硬件配置信息*/
    void (*w_sda)(soft_i2c_cnf_t *cnf, rt_uint32_t state);

    void (*w_scl)(soft_i2c_cnf_t *cnf, rt_uint32_t state);

    rt_int32_t (*r_sda)(soft_i2c_cnf_t *cnf);

    rt_int32_t (*r_scl)(soft_i2c_cnf_t *cnf);

    void (*us_delay)(rt_uint32_t us);


    struct {
        rt_uint32_t delay_us;
        rt_uint32_t timeout;
    } option;
} i2c_bit_ops_t; /*软件位操作*/

#define RT_I2C_WR                0x0000
#define RT_I2C_RD               (1u << 0)
#define RT_I2C_ADDR_10BIT       (1u << 2)  /* this is a ten bit chip address */
#define RT_I2C_NO_START         (1u << 4)
#define RT_I2C_IGNORE_NACK      (1u << 5)
#define RT_I2C_NO_READ_ACK      (1u << 6)  /* when I2C reading, we do not ACK */
#define RT_I2C_NO_STOP          (1u << 7)
typedef struct {
    rt_uint16_t addr;
    rt_uint16_t flags;
    rt_uint16_t len;
    rt_uint8_t *buf;
} rt_i2c_msg;

struct i2c_bus_device {
    i2c_bit_ops_t *bit_ops;

    struct {
        void (*start)(i2c_bit_ops_t *bit_ops); /*开启*/
        void (*stop)(i2c_bit_ops_t *bit_ops); /*停止*/
        rt_int32_t (*w_byte)(i2c_bit_ops_t *bit_ops, uint8_t data); /*write 1 byte*/
        rt_int32_t (*r_byte)(i2c_bit_ops_t *bit_ops);/*read 1 byte*/
        rt_bool_t (*wait_ack)(i2c_bit_ops_t *bit_ops);/*等待应答*/
        rt_int32_t (*send_ack_or_nack)(i2c_bit_ops_t *bit_ops, rt_int32_t ack); /*发送ack或nack*/

        rt_uint32_t (*w_bytes)(i2c_bit_ops_t *bit_ops, rt_i2c_msg *msg);

        rt_uint32_t (*r_bytes)(i2c_bit_ops_t *bit_ops, rt_i2c_msg *msg);

        rt_int32_t (*send_address)(i2c_bit_ops_t *bit_ops, uint8_t addr, rt_int32_t retries);

        rt_int32_t (*bit_send_address)(i2c_bit_ops_t *bit_ops, rt_i2c_msg *msg);

    } api;

    rt_uint32_t (*master_xfer)(i2c_bit_ops_t *bit_ops, rt_i2c_msg msgs[], rt_uint32_t num);
};/*I2C总线设备*/
typedef struct i2c_bus_device *i2c_bus_device_t;

void i2c_bus_init(i2c_bus_device_t device, i2c_bit_ops_t *i2c_ops, soft_i2c_cnf_t *cfg);

rt_size_t i2c_master_send(i2c_bus_device_t device, rt_uint16_t addr, rt_uint16_t flags, const rt_uint8_t *buf,
                          rt_uint32_t count);

rt_size_t i2c_master_rec(i2c_bus_device_t device, rt_uint16_t addr, rt_uint16_t flags, rt_uint8_t *buf,
                         rt_uint32_t count);

#endif //STM32_F1XX_TEMPLATE_BSP_I2C_SOFT_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
  • 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
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

源码


#include "bsp_i2c_soft.h"
#include "sys_dbg.h"

/*————————————————————————————————————————————————基础外设层——————————————————————————————————————————————————*/
sys_force_static_inline void stm32_us_delay(rt_uint32_t us) {
    uint32_t start, now, delta, reload, us_tick;
    start = SysTick->VAL;
    reload = SysTick->LOAD;
    us_tick = SystemCoreClock / 1000000UL;
    do {
        now = SysTick->VAL;
        delta = start > now ? start - now : reload + start - now;
    } while (delta < us_tick * us);
}

sys_force_static_inline void w_sda(soft_i2c_cnf_t *cnf, rt_uint32_t state) {
    if (state) {
        pin_high(cnf->port_sda, cnf->sda);
    } else {
        pin_low(cnf->port_sda, cnf->sda);

    }
}

sys_force_static_inline void w_scl(soft_i2c_cnf_t *cnf, rt_uint32_t state) {
    if (state) {
        pin_high(cnf->port_scl, cnf->scl);
    } else {
        pin_low(cnf->port_scl, cnf->scl);
    }
}

sys_force_static_inline rt_int32_t r_sda(soft_i2c_cnf_t *cnf) {
    return pin_read(cnf->port_sda, cnf->sda);
}

sys_force_static_inline rt_int32_t r_scl(soft_i2c_cnf_t *cnf) {
    return pin_read(cnf->port_scl, cnf->scl);
}

sys_force_static_inline void i2c_soft_init(i2c_bit_ops_t *i2c_ops, soft_i2c_cnf_t *cfg) {
    i2c_ops->option.delay_us = 1;
    i2c_ops->option.timeout = 100;
    i2c_ops->cnf = cfg;
    i2c_ops->w_scl = w_scl;
    i2c_ops->w_sda = w_sda;
    i2c_ops->r_sda = r_sda;
    i2c_ops->r_scl = r_scl;
    i2c_ops->us_delay = stm32_us_delay;
    stm32_pin_mode(cfg->port_scl, cfg->scl, pin_mode_output_od);
    stm32_pin_mode(cfg->port_sda, cfg->sda, pin_mode_output_od);

    pin_high(cfg->port_scl, cfg->scl);
    pin_high(cfg->port_sda, cfg->sda);
}
/*————————————————————————————————————————————————设备层——————————————————————————————————————————————————*/
#define SET_SDA(ops, val)   ops->w_sda(ops->cnf,val)
#define SET_SCL(ops, val)   ops->w_scl(ops->cnf,val)
#define GET_SDA(ops)        ops->r_sda(ops->cnf)
#define GET_SCL(ops)        ops->r_scl(ops->cnf)
#define SDA_L(ops)          SET_SDA(ops,0)
#define SDA_H(ops)          SET_SDA(ops,1)
#define SCL_L(ops)          SET_SCL(ops,0)

static void us_delay(i2c_bit_ops_t *bit_ops) {
    bit_ops->us_delay((bit_ops->option.delay_us + 1) >> 1);
}

static void us_delay2(i2c_bit_ops_t *bit_ops) {
    bit_ops->us_delay(bit_ops->option.delay_us);
}

static int SCL_H(i2c_bit_ops_t *bit_ops) {
    rt_uint32_t start;
    SET_SCL(bit_ops, 1);
    start = HAL_GetTick();
    while (!GET_SCL(bit_ops)) {
        if ((HAL_GetTick() - start) > bit_ops->option.timeout)
            return -1;
        us_delay(bit_ops);
    }


    us_delay(bit_ops);


    return 0;
}

sys_force_static_inline rt_int32_t send_ack_or_nack(i2c_bit_ops_t *bit_ops, rt_int32_t ack) {
    if (ack)
        SET_SDA(bit_ops, 0);
    us_delay(bit_ops);
    if (SCL_H(bit_ops) < 0) {
        return -1;
    }
    SCL_L(bit_ops);
    return 0;
}

sys_force_static_inline rt_bool_t wait_ack(i2c_bit_ops_t *bit_ops) {
    bool ack;

    SDA_H(bit_ops);
    us_delay(bit_ops);


    if (SCL_H(bit_ops) < 0) {

        return -1;
    }

    ack = !GET_SDA(bit_ops);    /* ACK : SDA pin is pulled low */


    SCL_L(bit_ops);

    return ack;
}/*等待应答*/
sys_force_static_inline void start(i2c_bit_ops_t *bit_ops) {
    SDA_L(bit_ops);
    us_delay(bit_ops);

    SCL_L(bit_ops);
} /*开启*/
static void restart(i2c_bit_ops_t *bit_ops) {
    SDA_H(bit_ops);
    SCL_H(bit_ops);
    us_delay(bit_ops);
    SDA_L(bit_ops);
    us_delay(bit_ops);
    SCL_L(bit_ops);
}

sys_force_static_inline void stop(i2c_bit_ops_t *bit_ops) {
    SDA_L(bit_ops);
    us_delay(bit_ops);
    SCL_H(bit_ops);
    us_delay(bit_ops);
    SDA_H(bit_ops);
    us_delay2(bit_ops);

} /*停止*/

sys_force_static_inline rt_int32_t w_byte(i2c_bit_ops_t *bit_ops, uint8_t data) {
    uint8_t bit;
    for (int i = 7; i >= 0; i--) {
        SCL_L(bit_ops);
        bit = (data >> i) & 1;
        SET_SDA(bit_ops, bit);

        us_delay(bit_ops);
        if (SCL_H(bit_ops) < 0) {


            return -1;
        }
    }
    SCL_L(bit_ops);
    us_delay(bit_ops);
    return wait_ack(bit_ops);
} /*write 1 byte*/
sys_force_static_inline rt_int32_t r_byte(i2c_bit_ops_t *bit_ops) {
    uint8_t i;
    uint8_t data = 0;

    SDA_H(bit_ops);
    us_delay(bit_ops);
    for (i = 0; i < 8; i++) {
        data <<= 1;

        if (SCL_H(bit_ops) < 0) {
            return -1;
        }

        if (GET_SDA(bit_ops))
            data |= 1;
        SCL_L(bit_ops);
        us_delay2(bit_ops);
    }

    return data;
}

sys_force_static_inline rt_uint32_t w_bytes(i2c_bit_ops_t *bit_ops, rt_i2c_msg *msg) {
    rt_int32_t ret;
    size_t bytes = 0;
    const uint8_t *ptr = msg->buf;
    rt_int32_t count = msg->len;
    uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
    while (count > 0) {
        ret = w_byte(bit_ops, *ptr);
        if ((ret > 0) || (ignore_nack && (ret == 0))) {
            count--;
            ptr++;
            bytes++;
        } else if (ret == 0) {
            return 0;
        } else {
            return ret;
        }
    }

    return bytes;
}

static rt_uint32_t r_bytes(i2c_bit_ops_t *bit_ops, rt_i2c_msg *msg) {
    rt_int32_t val;
    rt_int32_t bytes = 0;   /* actual bytes */
    uint8_t *ptr = msg->buf;
    rt_int32_t count = msg->len;
    const rt_uint32_t flags = msg->flags;
    while (count > 0) {
        val = r_byte(bit_ops);
        if (val >= 0) {
            *ptr = val;
            bytes++;
        } else {
            break;
        }

        ptr++;
        count--;
        if (!(flags & RT_I2C_NO_READ_ACK)) {
            val = send_ack_or_nack(bit_ops, count);
            if (val < 0)
                return val;
        }
    }

    return bytes;
}

static rt_int32_t send_address(i2c_bit_ops_t *bit_ops, uint8_t addr, rt_int32_t retries) {
    rt_int32_t i;
    rt_int32_t ret = 0;

    for (i = 0; i <= retries; i++) {
        ret = w_byte(bit_ops, addr);
        if (ret == 1 || i == retries)
            break;
        stop(bit_ops);
        us_delay2(bit_ops);
        start(bit_ops);
    }
    return ret;
}

static rt_int32_t bit_send_address(i2c_bit_ops_t *bit_ops, rt_i2c_msg *msg) {
    uint16_t flags = msg->flags;
    uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
    uint8_t addr1, addr2;
    rt_int32_t retries = 0;
    rt_int32_t ret;
//    retries = ignore_nack ? 0 : bus->retries;
    if (flags & RT_I2C_ADDR_10BIT) {
        addr1 = 0xf0 | ((msg->addr >> 7) & 0x06);
        addr2 = msg->addr & 0xff;

        LOG_D("addr1: %d, addr2: %d", addr1, addr2);

        ret = send_address(bit_ops, addr1, retries);
        if ((ret != 1) && !ignore_nack) {
            LOG_W("NACK: sending first addr");

            return -RT_EIO;
        }

        ret = w_byte(bit_ops, addr2);
        if ((ret != 1) && !ignore_nack) {
            LOG_W("NACK: sending second addr");

            return -RT_EIO;
        }
        if (flags & RT_I2C_RD) {
            LOG_D("send repeated start condition");
            restart(bit_ops);
            addr1 |= 0x01;
            ret = send_address(bit_ops, addr1, retries);
            if ((ret != 1) && !ignore_nack) {
                LOG_E("NACK: sending repeated addr");

                return -RT_EIO;
            }
        }
    } else {
        /* 7-bit addr */
        addr1 = msg->addr << 1;
        if (flags & RT_I2C_RD)
            addr1 |= 1;
        ret = send_address(bit_ops, addr1, retries);
        if ((ret != 1) && !ignore_nack)
            return -8;
    }
    return 0;
}

/*————————————————————————————————————————————————协议逻辑层——————————————————————————————————————————————————*/
static rt_uint32_t bit_xfer(i2c_bit_ops_t *bit_ops, rt_i2c_msg msgs[], rt_uint32_t num) {
    rt_i2c_msg *msg;
    rt_int32_t i, ret;
    uint16_t ignore_nack;
    for (i = 0; i < num; i++) {
        msg = &msgs[i];
        ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
        if (!(msg->flags & RT_I2C_NO_START)) {
            if (i) {
                restart(bit_ops);
            } else {
                LOG_D("send start condition\r\n");
                start(bit_ops);
            }
            ret = bit_send_address(bit_ops, msg);
            if ((ret != 0) && !ignore_nack) {
                LOG_D("receive NACK from device addr 0x%02x msg %d\r\n",
                      msgs[i].addr, i);
                goto out;
            }
        }
        if (msg->flags & RT_I2C_RD) {
            ret = r_bytes(bit_ops, msg);
            if (ret >= 1)
                    LOG_D("read %d byte%s\r\n", ret, ret == 1 ? "" : "s");
            if (ret < msg->len) {
                if (ret >= 0)
                    ret = -8;
                goto out;
            }
        } else {
            ret = w_bytes(bit_ops, msg);
            if (ret >= 1) {
                LOG_D("write %d byte%s\r\n", ret, ret == 1 ? "" : "s");
            }
            if (ret < msg->len) {
                if (ret >= 0)
                    ret = -1;
                goto out;
            }
        }
    }
    ret = i;
    out:
    if (!(msg->flags & RT_I2C_NO_STOP)) {
        stop(bit_ops);
    }

    return ret;
}

sys_force_static_inline void i2c_device_registry(i2c_bus_device_t device, i2c_bit_ops_t *op) {
    device->bit_ops = op;
    device->api.start = start;
    device->api.stop = stop;
    device->api.w_byte = w_byte;
    device->api.r_byte = r_byte;
    device->api.wait_ack = wait_ack;
    device->api.send_ack_or_nack = send_ack_or_nack;
    device->api.w_bytes = w_bytes;
    device->api.r_bytes = r_bytes;
    device->api.send_address = send_address;
    device->api.bit_send_address = bit_send_address;
    device->master_xfer = bit_xfer;
}

void i2c_bus_init(i2c_bus_device_t device, i2c_bit_ops_t *i2c_ops, soft_i2c_cnf_t *cfg) {
    i2c_soft_init(i2c_ops, cfg);
    i2c_device_registry(device, i2c_ops);
}

rt_size_t rt_i2c_transfer(i2c_bus_device_t device, rt_i2c_msg msgs[], rt_uint32_t num) {
    if (device->master_xfer) {
        return device->master_xfer(device->bit_ops, msgs, num);
    }
    return 0;
}

rt_size_t i2c_master_send(i2c_bus_device_t device,
                          rt_uint16_t addr,
                          rt_uint16_t flags,
                          const rt_uint8_t *buf,
                          rt_uint32_t count) {
    rt_i2c_msg msg;
    msg.addr = addr;
    msg.flags = flags;
    msg.len = count;
    msg.buf = (uint8_t *) buf;
    rt_size_t ret = rt_i2c_transfer(device, &msg, 1);
    return (ret > 0) ? count : ret;
}

rt_size_t i2c_master_rec(i2c_bus_device_t device,
                         rt_uint16_t addr,
                         rt_uint16_t flags,
                         rt_uint8_t *buf,
                         rt_uint32_t count) {

    rt_err_t ret;
    rt_i2c_msg msg;

    msg.addr = addr;
    msg.flags = flags | RT_I2C_RD;
    msg.len = count;
    msg.buf = buf;

    ret = rt_i2c_transfer(device, &msg, 1);

    return (ret > 0) ? count : ret;
}

  • 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
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409

测试模块驱动(at24c02)

at24cxx,根据rt-thread里面搜索的包里面的源码来适配此驱动

  • 1

头文件

#ifndef STM32_F1XX_TEMPLATE_MODULE_AT24CXX_H
#define STM32_F1XX_TEMPLATE_MODULE_AT24CXX_H

#include "bsp.h"

#define AT24C01     0
#define AT24C02     1
#define AT24C04     2
#define AT24C08     3
#define AT24C16     4
#define AT24C32     5
#define AT24C64     6
#define AT24C128    7
#define AT24C256    8
#define AT24C512    9
#define AT24CTYPE   10   // Number of supported types
#define EE_TWR      5
#ifndef EE_TYPE
#define EE_TYPE     AT24C02
#endif

struct at24cxx_device {
    i2c_bus_device_t i2c;



    uint8_t AddrInput;
};

typedef struct at24cxx_device *at24cxx_device_t;

extern at24cxx_device_t at24cxx_init(i2c_bus_device_t i2c, uint8_t AddrInput);

extern rt_err_t at24cxx_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead);

extern rt_err_t at24cxx_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite);

extern rt_err_t at24cxx_page_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead);

extern rt_err_t at24cxx_page_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite);

extern rt_err_t at24cxx_check(at24cxx_device_t dev, uint16_t addr, uint8_t val);

#endif //STM32_F1XX_TEMPLATE_MODULE_AT24CXX_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
  • 41
  • 42
  • 43
  • 44

源文件

#define DBG_ENABLE
#define DBG_SECTION_NAME "at24xx"
#define DBG_LEVEL DBG_LOG

#include "sys_dbg.h"
#include "module-at24cxx.h"

#define AT24CXX_ADDR (0xA0 >> 1)                      //A0 A1 A2 connect GND

#if (EE_TYPE == AT24C01)
#define AT24CXX_PAGE_BYTE               8
#define AT24CXX_MAX_MEM_ADDRESS         128
#elif (EE_TYPE == AT24C02)
#define AT24CXX_PAGE_BYTE               8
#define AT24CXX_MAX_MEM_ADDRESS         256
#elif (EE_TYPE == AT24C04)
#define AT24CXX_PAGE_BYTE               16
#define AT24CXX_MAX_MEM_ADDRESS         512
#elif (EE_TYPE == AT24C08)
#define AT24CXX_PAGE_BYTE               16
#define AT24CXX_MAX_MEM_ADDRESS         1024
#elif (EE_TYPE == AT24C16)
#define AT24CXX_PAGE_BYTE               16
#define AT24CXX_MAX_MEM_ADDRESS         2048
#elif (EE_TYPE == AT24C32)
#define AT24CXX_PAGE_BYTE               32
#define AT24CXX_MAX_MEM_ADDRESS         4096
#elif (EE_TYPE == AT24C64)
#define AT24CXX_PAGE_BYTE               32
#define AT24CXX_MAX_MEM_ADDRESS         8192
#elif (EE_TYPE == AT24C128)
#define AT24CXX_PAGE_BYTE               64
#define AT24CXX_MAX_MEM_ADDRESS         16384
#elif (EE_TYPE == AT24C256)
#define AT24CXX_PAGE_BYTE               64
#define AT24CXX_MAX_MEM_ADDRESS         32768
#elif (EE_TYPE == AT24C512)
#define AT24CXX_PAGE_BYTE               128
#define AT24CXX_MAX_MEM_ADDRESS         65536
#endif

sys_force_static_inline rt_err_t read_regs(at24cxx_device_t dev, rt_uint8_t len, rt_uint8_t *buf) {
    rt_i2c_msg msgs;

    msgs.addr = AT24CXX_ADDR | dev->AddrInput;
    msgs.flags = RT_I2C_RD;
    msgs.buf = buf;
    msgs.len = len;
    if (dev->i2c->master_xfer(dev->i2c->bit_ops, &msgs, 1) == 1) {
        return RT_EOK;
    } else {
        return -RT_ERROR;
    }
}

sys_force_static_inline uint8_t at24cxx_read_one_byte(at24cxx_device_t dev, uint16_t readAddr) {
    rt_uint8_t buf[2];
    rt_uint8_t temp;
#if (EE_TYPE > AT24C16)
    buf[0] = (uint8_t)(readAddr>>8);
    buf[1] = (uint8_t)readAddr;
    if (rt_i2c_master_send(dev->i2c, AT24CXX_ADDR, 0, buf, 2) == 0)
#else
    buf[0] = readAddr;
    if (i2c_master_send(dev->i2c, AT24CXX_ADDR | dev->AddrInput, 0, buf, 1) == 0)
#endif
    {
        return RT_ERROR;
    }
    read_regs(dev, 1, &temp);
    return temp;
}

sys_force_static_inline rt_err_t
at24cxx_write_one_byte(at24cxx_device_t dev, uint16_t writeAddr, uint8_t dataToWrite) {
    rt_uint8_t buf[3];
#if (EE_TYPE > AT24C16)
    buf[0] = (uint8_t)(writeAddr>>8);
    buf[1] = (uint8_t)writeAddr;
    buf[2] = dataToWrite;
    if (rt_i2c_master_send(dev->i2c, AT24CXX_ADDR, 0, buf, 3) == 3)
#else
    buf[0] = writeAddr; //cmd
    buf[1] = dataToWrite;
    //buf[2] = data[1];

    if (i2c_master_send(dev->i2c, AT24CXX_ADDR | dev->AddrInput, 0, buf, 2) == 2)
#endif
        return RT_EOK;
    else
        return -RT_ERROR;

}

sys_force_static_inline rt_err_t
at24cxx_read_page(at24cxx_device_t dev, uint32_t readAddr, uint8_t *pBuffer, uint16_t numToRead) {
    rt_i2c_msg msgs[2];
    uint8_t AddrBuf[2];

    msgs[0].addr = AT24CXX_ADDR | dev->AddrInput;
    msgs[0].flags = RT_I2C_WR;

#if (EE_TYPE > AT24C16)
    AddrBuf[0] = readAddr >> 8;
    AddrBuf[1] = readAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 2;
#else
    AddrBuf[0] = readAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 1;
#endif

    msgs[1].addr = AT24CXX_ADDR | dev->AddrInput;
    msgs[1].flags = RT_I2C_RD;
    msgs[1].buf = pBuffer;
    msgs[1].len = numToRead;

    if (dev->i2c->master_xfer(dev->i2c->bit_ops, msgs, 2) == 0) {
        return RT_ERROR;
    }
    return RT_EOK;
}

sys_force_static_inline rt_err_t
at24cxx_write_page(at24cxx_device_t dev, uint32_t wirteAddr, uint8_t *pBuffer, uint16_t numToWrite) {
    rt_i2c_msg msgs[2];
    uint8_t AddrBuf[2];

    msgs[0].addr = AT24CXX_ADDR | dev->AddrInput;
    msgs[0].flags = RT_I2C_WR;

#if (EE_TYPE > AT24C16)
    AddrBuf[0] = wirteAddr >> 8;
    AddrBuf[1] = wirteAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 2;
#else
    AddrBuf[0] = wirteAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 1;
#endif

    msgs[1].addr = AT24CXX_ADDR | dev->AddrInput;
    msgs[1].flags = RT_I2C_WR | RT_I2C_NO_START;
    msgs[1].buf = pBuffer;
    msgs[1].len = numToWrite;

    if (dev->i2c->master_xfer(dev->i2c->bit_ops, msgs, 2) <= 0) {
        return RT_ERROR;
    }

    return RT_EOK;
}

at24cxx_device_t at24cxx_init(i2c_bus_device_t i2c, uint8_t AddrInput) {
    at24cxx_device_t dev;
    dev = rt_calloc(1, sizeof(at24cxx_device_t));

    if (dev == NULL)
        return dev;
    dev->i2c = i2c;
    dev->AddrInput = AddrInput;
    return dev;
}

rt_err_t at24cxx_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead) {
    if (ReadAddr + NumToRead > AT24CXX_MAX_MEM_ADDRESS) {
        return RT_ERROR;
    }
    while (NumToRead) {
        *pBuffer++ = at24cxx_read_one_byte(dev, ReadAddr++);
        NumToRead--;
    }
    return RT_EOK;
}

rt_err_t at24cxx_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite) {
    uint16_t i = 0;
    if (WriteAddr + NumToWrite > AT24CXX_MAX_MEM_ADDRESS) {
        return RT_ERROR;
    }
    while (1) //NumToWrite--
    {
        if (at24cxx_write_one_byte(dev, WriteAddr, pBuffer[i]) == RT_EOK) {
            bsp_ms_delay(2);
            WriteAddr++;
        }
        if (++i == NumToWrite) {
            break;
        }
        bsp_ms_delay(EE_TWR);
    }
    return RT_EOK;
}

rt_err_t at24cxx_check(at24cxx_device_t dev, uint16_t addr, uint8_t val) {
    uint8_t temp;
    temp = at24cxx_read_one_byte(dev, addr);
    if (temp == val) return RT_EOK;
    else {
        at24cxx_write_one_byte(dev, addr, val);
        bsp_ms_delay(EE_TWR);            // wait 5ms befor next operation
        temp = at24cxx_read_one_byte(dev, addr);
        if (temp == val) return RT_EOK;
    }
    return RT_ERROR;
}

rt_err_t at24cxx_page_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead) {
    rt_err_t result = RT_EOK;
    uint16_t pageReadSize = AT24CXX_PAGE_BYTE - ReadAddr % AT24CXX_PAGE_BYTE;
    if (ReadAddr + NumToRead > AT24CXX_MAX_MEM_ADDRESS) {
        return RT_ERROR;
    }
    while (NumToRead) {
        if (NumToRead > pageReadSize) {
            if (at24cxx_read_page(dev, ReadAddr, pBuffer, pageReadSize)) {
                result = RT_ERROR;
            }

            ReadAddr += pageReadSize;
            pBuffer += pageReadSize;
            NumToRead -= pageReadSize;
            pageReadSize = AT24CXX_PAGE_BYTE;
        } else {
            if (at24cxx_read_page(dev, ReadAddr, pBuffer, NumToRead)) {
                result = RT_ERROR;
            }
            NumToRead = 0;
        }
    }


    return result;
}

rt_err_t at24cxx_page_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite) {
    rt_err_t result = RT_EOK;
    uint16_t pageWriteSize = AT24CXX_PAGE_BYTE - WriteAddr % AT24CXX_PAGE_BYTE;
    if (WriteAddr + NumToWrite > AT24CXX_MAX_MEM_ADDRESS) {
        return RT_ERROR;
    }

    while (NumToWrite) {
        if (NumToWrite > pageWriteSize) {
            if (at24cxx_write_page(dev, WriteAddr, pBuffer, pageWriteSize)) {
                result = RT_ERROR;
            }
            bsp_ms_delay(EE_TWR);   // wait 5ms befor next operation

            WriteAddr += pageWriteSize;
            pBuffer += pageWriteSize;
            NumToWrite -= pageWriteSize;
            pageWriteSize = AT24CXX_PAGE_BYTE;
        } else {
            if (at24cxx_write_page(dev, WriteAddr, pBuffer, NumToWrite)) {
                result = RT_ERROR;
            }
            bsp_ms_delay(EE_TWR);   // wait 5ms befor next operation

            NumToWrite = 0;
        }
    }

    return result;
}

  • 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
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267

测试源码

#include "bsp_i2c_soft.h"
#include "module-at24cxx.h"

#define DBG_ENABLE
#define DBG_SECTION_NAME "at24xx_test"
#define DBG_LEVEL DBG_LOG

#include "sys_dbg.h"

soft_i2c_cnf_t I2C_Gpio_Cnf = {
        .port_sda = GPIOB,
        .port_scl =GPIOB,
        .scl=GPIO_PIN_6,
        .sda=GPIO_PIN_7,
};
i2c_bit_ops_t bit_ops = {
        .option={
                .delay_us =1,
                .timeout=100
        }
};
struct i2c_bus_device i2c_device;
at24cxx_device_t at24CxxDevice;

static void pre_init(void) {


}

static void init(void) {
    i2c_bus_init(&i2c_device, &bit_ops, &I2C_Gpio_Cnf);
}


rt_uint8_t data[] = {12, 3, 4, 5, 7, 2, 5, 7, 4, 2};
rt_uint8_t read_data[10];

static void after_init(void) {
    at24CxxDevice = at24cxx_init(&i2c_device, 0);
    if (at24cxx_page_write(at24CxxDevice, 0x1, data, sizeof(data)) == RT_EOK) {
        LOG_D("write data ok\r\n");
        HAL_Delay(5);
        if (at24cxx_page_read(at24CxxDevice, 0x1, read_data, sizeof(read_data)) == RT_EOK) {
            LOG_D("read data ok\r\n");
        }

    }


}
//app_init_export(i2c_soft_test, pre_init, init, after_init);

  • 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
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/一键难忘520/article/detail/982701
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号