RT-Thread-I2C，DS1307时钟芯片，测试成功驱动代码分享RT-Thread问答社区

I2C，DS1307时钟芯片，测试成功驱动代码分享

发布于 2020-01-07 16:45:29 浏览：2086 订阅该版

```c
/*
 * 一堆科技 WJ
 *
 * 
 *
 * Change Logs:
 * Date                  Author           Notes
 * 2020-01-07            wj        first implementation.
 */
/*
 * 程序清单：这是一个 I2C 设备DS1307使用例程
 * 例程导出了 i2c_ds1307_sample 命令到控制终端
 * 命令调用格式：i2c_ds1307_sample i2c1
 * 命令解释：命令第二个参数是要使用的I2C总线设备名称，为空则使用默认的I2C总线设备
 * 程序功能：通过 I2C 设备读取DS1307的时间数据并打印
*/

#include <rtthread.h>
#include <rtdevice.h>

#define DS1307_I2C_BUS_NAME          "i2c1"  /* 传感器连接的I2C总线设备名称 */

extern void i2c_ds1307_sample(int argc, char *argv[]);
rt_uint8_t HEX_BCD(rt_uint8_t val);    //Byte转BCD
rt_uint8_t BCD_HEX(rt_uint8_t val);    //BCD转Byte

static struct rt_i2c_bus_device *i2c_bus = RT_NULL;     /* I2C总线设备句柄 */
static rt_bool_t initialized = RT_FALSE;                /* 传感器初始化状态 */

typedef struct
{
    rt_uint8_t second;  //秒
    rt_uint8_t minute;  //分
    rt_uint8_t hour;    //时
    rt_uint8_t week;    //星期
    rt_uint8_t date;    //日
    rt_uint8_t month;   //月
    rt_uint16_t year;    //年
}Time_Typedef;
Time_Typedef TimeValue;  //定义时间缓存指针

#define DS1307_ID                         0x68        //DS1307 器件地址
#define Address_second          0x00    //秒 寄存器地址
#define Address_minute          0x01    //分 寄存器地址
#define Address_hour             0x02    //时 寄存器地址
#define Address_week            0x03    //星期 寄存器地址
#define Address_date             0x04    //日 寄存器地址
#define Address_month          0x05    //月 寄存器地址
#define Address_year             0x06    //年 寄存器地址

/* 写寄存器 */
static rt_err_t write_reg(struct rt_i2c_bus_device *bus, rt_uint8_t reg, rt_uint8_t data)//write_reg(i2c_bus, Address_second, data)
{
    rt_uint8_t buf[2]={0};
    struct rt_i2c_msg msgs;
                
    buf[0] = reg;
    buf[1] = data;
                
    msgs.addr = DS1307_ID;
    msgs.flags = RT_I2C_WR;
    msgs.buf = buf;
    msgs.len = 2;

/* 调用I2C设备接口传输数据 */
 if (rt_i2c_transfer(bus, &msgs, 1) == 1)
 {
 rt_kprintf("write_reg OK! ");
 return RT_EOK;
 }
 else
 {
 rt_kprintf("write_reg NO! ");
 return -RT_ERROR;
 }
}

/* 读传感器寄存器数据 */
rt_err_t read_regs(struct rt_i2c_bus_device *bus, rt_uint8_t reg, rt_uint8_t *buf) //read_regs(i2c_bus, Address_second, &buf)
{
    struct rt_i2c_msg msgs[2];

msgs[0].addr = DS1307_ID;
    msgs[0].flags = RT_I2C_WR;
    msgs[0].buf = ®
    msgs[0].len = 1;

msgs[1].addr = DS1307_ID;
 msgs[1].flags = RT_I2C_RD;
 msgs[1].buf = buf;
 msgs[1].len = 1;
 
 /* 调用I2C设备接口传输数据 */
 if (rt_i2c_transfer(bus, &msgs[0], 2) == 2)
 {
 rt_kprintf("read_regs OK! ");
 return RT_EOK;
 }
 else
 {
 rt_kprintf("read_regs NO! ");
 return -RT_ERROR;
 }
}

/* 修改时间 */
static void write_ymd_hms(void)
{
    rt_uint8_t wj_time=0;

TimeValue.year = 20;
        TimeValue.month = 1;
        TimeValue.date = 2;
        TimeValue.week = 2;
        TimeValue.hour = 13;
        TimeValue.minute = 55;
        TimeValue.second = 45;
        
    wj_time=HEX_BCD(TimeValue.year);
    write_reg(i2c_bus,Address_year,wj_time);   //年

wj_time=HEX_BCD(TimeValue.month);
    write_reg(i2c_bus,Address_month,wj_time);  //月

wj_time=HEX_BCD(TimeValue.date);
    write_reg(i2c_bus,Address_date,wj_time);   //日

wj_time=HEX_BCD(TimeValue.week);
    write_reg(i2c_bus,Address_week,wj_time);   //周

wj_time=HEX_BCD(TimeValue.hour);
    write_reg(i2c_bus,Address_hour,wj_time);   //时

wj_time=HEX_BCD(TimeValue.minute);
    write_reg(i2c_bus,Address_minute,wj_time); //分

wj_time=HEX_BCD(TimeValue.second);
    write_reg(i2c_bus,Address_second,wj_time); //秒
}

/* 读取时间 */
static void read_ymd_hms(void)
{
 rt_uint8_t wj_time=0;
 rt_uint8_t ret=0;
 
 read_regs(i2c_bus,Address_year,&wj_time); //年
 TimeValue.year=(BCD_HEX(wj_time))+2000;
 
 read_regs(i2c_bus,Address_month,&wj_time); //月
 TimeValue.month=BCD_HEX(wj_time);
 
 read_regs(i2c_bus,Address_date,&wj_time); //日
 TimeValue.date=BCD_HEX(wj_time);
 
 read_regs(i2c_bus,Address_week,&wj_time); //周
 TimeValue.week=BCD_HEX(wj_time);
 
 read_regs(i2c_bus,Address_hour,&wj_time); //时
 TimeValue.hour=BCD_HEX(wj_time);
 
 read_regs(i2c_bus,Address_minute,&wj_time); //分
 TimeValue.minute=BCD_HEX(wj_time);
 
 read_regs(i2c_bus,Address_second,&wj_time); //秒
 TimeValue.second=BCD_HEX(wj_time);
 
 if(TimeValue.hour>23)
 ret++;
 if(TimeValue.month>59)
 ret++;
 if(TimeValue.second>59)
 ret++;
 if(TimeValue.year-2000>99)
 ret++;
 if((TimeValue.month>12)||(TimeValue.month==0))
 ret++;
 if((TimeValue.date>31)||(TimeValue.date==0))
 ret++;
 if (ret>0)
 rt_kprintf("read ds1307 err : %d ", ret);
}

/* 获取ds1307 i2c1 */
static void ds1307_init(const char *name)
{
 /* 查找I2C总线设备，获取I2C总线设备句柄 */
 //i2c_bus = (struct rt_i2c_bus_device *)rt_device_find(name);
 i2c_bus = (struct rt_i2c_bus_device *) rt_i2c_bus_device_find(name);
 
 if (i2c_bus == RT_NULL)
 {
 rt_kprintf("can't find %s device! ", name);
 }
 initialized = RT_TRUE;
}

/* BCD转Byte */
rt_uint8_t BCD_HEX(rt_uint8_t val)
{
    rt_uint8_t temp;
    temp=val&0x0f;
    val>>=4;
    val&=0x0f;
    val*=10;
    temp+=val;

return temp;
}

/* Byte转BCD */
rt_uint8_t HEX_BCD(rt_uint8_t val)
{
 rt_uint8_t i,j,k;
 i=val/10;
 j=val%10;
 k=j+(i<<4);
 return k;
}

/* WJ_DS1307实例 */
void i2c_ds1307_sample(int argc, char *argv[])
{
    char name[RT_NAME_MAX];

if (argc == 2)
    {
        rt_strncpy(name, argv[1], RT_NAME_MAX);
    }
    else
    {
        rt_strncpy(name, DS1307_I2C_BUS_NAME, RT_NAME_MAX);
    }

if (!initialized)
    {
        /* 传感器初始化 */
        ds1307_init(name);
    }
    if (initialized)
    {
        /* 写入 年月日 时分秒 */
        write_ymd_hms();
                
        /* 读取 年月日 时分秒 */
        read_ymd_hms();

rt_kprintf("read ds1307 data : %d,%d,%d,%d,%d,%d,%d ", (int)TimeValue.year, (int)TimeValue.month, (int)TimeValue.date, (int)TimeValue.week, (int)TimeValue.hour, (int)TimeValue.minute, (int)TimeValue.second);
 }
 else
 {
 rt_kprintf("initialize sensor failed! ");
 }
}
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(i2c_ds1307_sample, wj i2c ds1307 sample);
```

备注！！！！
因为版本问题，ENV设置引脚，可能造成GPIO驱动不起来，故在drv_soft_i2c.h中加入定义：
```c
#define BSP_I2C1_SCL_PIN GET_PIN(B,6)  //i2c1 SCL
#define BSP_I2C1_SDA_PIN GET_PIN(B,7)  //i2c1 SDA
```