21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 国产risc-v微控制器读取DS3231
返回列表 发新帖我要提问

[RISC-V MCU 应用开发] 国产risc-v微控制器读取DS3231

[复制链接]
559|1
dirtwillfly 发表于 2025-9-28 13:41 | 显示全部楼层 |阅读模式
微控制器, DS3231, RISC-V, TI, 读取, RT
本帖最后由 dirtwillfly 于 2025-9-28 20:30 编辑

第一部分：DS3231介绍
1.1 特性
DS3231 是一款 I2C 实时时钟 (RTC)，具有内置温度补偿晶体振荡器 (TCXO) 和低成本且异常精确的晶体。当模块的电源中断时，设备有电池输入并保持精确的时间。该器件的长期精度因包含晶体振荡器而得到提高。RTC 跟踪秒、分钟、小时、天、日期、月和年。对于少于 31 天的月份，月末日期会自动修改，包括闰年更正。时钟具有 AM/PM 指示，可在 24 小时或 12 小时模式下工作。包括两个可编程的时间警报，以及一个可编程的方波输出。I2C 双向总线用于串行传输地址和数据。


关键特性：
• 高精确时钟 ：具有+/-2ppm（百万分之二）的精度，从0°C到+40°C。
• 温度补偿 ：内置温度传感器，能够自动补偿时钟频率偏移。
• 集成备份电池 ：当主电源失效时，内置锂电池自动切换，保证时钟继续运行

1.2 参数
  • 0°C至+40°C范围内精度为±2ppm
  • -40°C至+85°C范围内精度为±3.5ppm
  • 为连续计时提供电池备份输入
  • 工作温度范围
    • 商用级：0°C至+70°C
    • 工业级：-40°C至+85°C
  • 低功耗
  • 实时时钟产生秒、分、时、星期、日期、月和年计时，并提供有效期到2100年的闰年补偿
  • 两个日历闹钟
  • 可编程方波输出
  • 高速(400kHz) I²C接口
  • 工作在3.3V
  • 数字温度传感器输出：精度为±3°C
  • 老化修正寄存器
  • /RST输出/按钮复位去抖输入


1.3 电路原理图
使用的模块：
339668d8ccfe41803.png
与ds3231相关的原理图：
3612868d8ccbf691cc.png
其中有一点要特别注意，因为原理图中VCC经过限流电阻和二极管连接到BAT，这是一个BAT的限流充电电路。所以这里的BAT电池必须使用可充电的CR2032。

第二部分：应用开发
2.1 硬件连接方式
使用的HPM5361开发板P1接口有两组I2C接口，这里使用I2C0接口，即PB03和PB02引脚。



这两个引脚，在开发板上已经有了10K的上拉电阻，使用的DS3231上也有上拉电阻，这里可以共存，不需要特殊处理。

2.2 驱动代码
复制

  1. 

  2. #define     DS3231_ARRD         0x68    /* slave address */
    


  3. 

  4. #define     REG_SEC             0x00
    

  5. #define     REG_MIN             0x01
    

  6. #define     REG_HOUR            0x02
    

  7. #define     REG_DAY             0x03
    

  8. #define     REG_WEEK            0x04
    

  9. #define     REG_MON             0x05
    

  10. #define     REG_YEAR            0x06
    

  11. #define     REG_ALM1_SEC        0x07
    

  12. #define     REG_ALM1_MIN        0x08
    

  13. #define     REG_ALM1_HOUR       0x09
    

  14. #define     REG_ALM1_DAY_DATE   0x0A
    

  15. #define     REG_ALM2_MIN        0x0B
    

  16. #define     REG_ALM2_HOUR       0x0C
    

  17. #define     REG_ALM2_DAY_DATE   0x0D
    

  18. #define     REG_CONTROL         0x0E
    

  19. #define     REG_STATUS          0x0F
    

  20. #define     REG_AGING_OFFSET    0x10
    

  21. #define     REG_TEMP_MSB        0x11
    

  22. #define     REG_TEMP_LSB        0x12
    


  23. 

  24. #define DS3231_I2C_BUS      "i2c0"      /* i2c linked */
    

  25. #define DS3231_DEVICE_NAME  "rtc"       /* register device name */
    


  26. 

  27. static struct rt_device ds3231_dev; /* ds3231 device */
    


  28. 

  29. static unsigned char bcd_to_hex(unsigned char data)
    

  30. {
    

  31.     unsigned char temp;
    


  32. 

  33.     temp = ((data>>4)*10 + (data&0x0f));
    

  34.     return temp;
    

  35. }
    


  36. 

  37. static unsigned char hex_to_bcd(unsigned char data)
    

  38. {
    

  39.     unsigned char temp;
    


  40. 

  41.     temp = (((data/10)<<4) + (data%10));
    

  42.     return temp;
    

  43. }
    


  44. 

  45. static rt_err_t  ds3231_read_reg(rt_device_t dev, rt_uint8_t reg,rt_uint8_t *data,rt_uint8_t data_size)
    

  46. {
    

  47.     struct rt_i2c_msg msg[2];
    

  48.     struct rt_i2c_bus_device *i2c_bus = RT_NULL;
    


  49. 

  50.     RT_ASSERT(dev != RT_NULL);
    


  51. 

  52.     i2c_bus = (struct rt_i2c_bus_device*)dev->user_data;
    

  53.     msg[0].addr  = DS3231_ARRD;
    

  54.     msg[0].flags = RT_I2C_WR;
    

  55.     msg[0].len   = 1;
    

  56.     msg[0].buf   = &reg;
    

  57.     msg[1].addr  = DS3231_ARRD;
    

  58.     msg[1].flags = RT_I2C_RD;
    

  59.     msg[1].len   = data_size;
    

  60.     msg[1].buf   = data;
    


  61. 

  62.     if(rt_i2c_transfer(i2c_bus, msg, 2) == 2)
    

  63.     {
    

  64.         return RT_EOK;
    

  65.     }
    

  66.     else
    

  67.     {
    

  68.         LOG_E("i2c bus read failed!\r\n");
    

  69.         return -RT_ERROR;
    

  70.     }
    

  71. }
    


  72. 

  73. static rt_err_t  ds3231_write_reg(rt_device_t dev, rt_uint8_t reg, rt_uint8_t *data, rt_uint8_t data_size)
    

  74. {
    

  75.     struct rt_i2c_msg msg[2];
    

  76.     struct rt_i2c_bus_device *i2c_bus = RT_NULL;
    


  77. 

  78.     RT_ASSERT(dev != RT_NULL);
    


  79. 

  80.     i2c_bus = (struct rt_i2c_bus_device*)dev->user_data;
    

  81.     msg[0].addr     = DS3231_ARRD;
    

  82.     msg[0].flags    = RT_I2C_WR;
    

  83.     msg[0].len      = 1;
    

  84.     msg[0].buf      = &reg;
    

  85.     msg[1].addr     = DS3231_ARRD;
    

  86.     msg[1].flags    = RT_I2C_WR | RT_I2C_NO_START;
    

  87.     msg[1].len      = data_size;
    

  88.     msg[1].buf      = data;
    

  89.     if(rt_i2c_transfer(i2c_bus, msg, 2) == 2)
    

  90.     {
    

  91.         return RT_EOK;
    

  92.     }
    

  93.     else
    

  94.     {
    

  95.         LOG_E("i2c bus write failed!\r\n");
    

  96.         return -RT_ERROR;
    

  97.     }
    

  98. }
    


  99. 

  100. static rt_err_t rt_ds3231_open(rt_device_t dev, rt_uint16_t flag)
    

  101. {
    

  102.     if (dev->rx_indicate != RT_NULL)
    

  103.     {
    

  104.         /* open interrupt */
    

  105.     }
    


  106. 

  107.     return RT_EOK;
    

  108. }
    


  109. 

  110. static rt_size_t rt_ds3231_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
    

  111. {
    

  112.     return RT_EOK;
    

  113. }
    


  114. 

  115. static rt_err_t rt_ds3231_control(rt_device_t dev, int cmd, void *args)
    

  116. {
    

  117.     rt_err_t    ret = RT_EOK;
    

  118.     time_t      *time;
    

  119.     struct tm   time_temp;
    

  120.     rt_uint8_t  buff[7];
    


  121. 

  122.     RT_ASSERT(dev != RT_NULL);
    

  123.     rt_memset(&time_temp, 0, sizeof(struct tm));
    


  124. 

  125.     switch (cmd)
    

  126.     {
    

  127.         /* read time */
    

  128.         case RT_DEVICE_CTRL_RTC_GET_TIME:
    

  129.             time = (time_t *)args;
    

  130.             ret = ds3231_read_reg(dev, REG_SEC,buff,7);
    

  131.             if(ret == RT_EOK)
    

  132.             {
    

  133.                 time_temp.tm_year  = bcd_to_hex(buff[6]) + 2000 - 1900;
    

  134.                 time_temp.tm_mon   = bcd_to_hex(buff[5]&0x7f) - 1;
    

  135.                 time_temp.tm_mday  = bcd_to_hex(buff[4]);
    

  136.                 time_temp.tm_hour  = bcd_to_hex(buff[2]);
    

  137.                 time_temp.tm_min   = bcd_to_hex(buff[1]);
    

  138.                 time_temp.tm_sec   = bcd_to_hex(buff[0]);
    

  139.                 *time = mktime(&time_temp);
    

  140.             }
    

  141.         break;
    


  142. 

  143.         /* set time */
    

  144.         case RT_DEVICE_CTRL_RTC_SET_TIME:
    

  145.         {
    

  146.             struct tm *time_new;
    


  147. 

  148.             time = (time_t *)args;
    

  149.             time_new = localtime(time);
    

  150.             buff[6] = hex_to_bcd(time_new->tm_year + 1900 - 2000);
    

  151.             buff[5] = hex_to_bcd(time_new->tm_mon + 1);
    

  152.             buff[4] = hex_to_bcd(time_new->tm_mday);
    

  153.             buff[3] = hex_to_bcd(time_new->tm_wday+1);
    

  154.             buff[2] = hex_to_bcd(time_new->tm_hour);
    

  155.             buff[1] = hex_to_bcd(time_new->tm_min);
    

  156.             buff[0] = hex_to_bcd(time_new->tm_sec);
    

  157.             ret = ds3231_write_reg(dev, REG_SEC, buff, 7);
    

  158.         }
    

  159.         break;
    

  160.     #ifdef RT_USING_ALARM
    

  161.         /* get alarm time */
    

  162.         case RT_DEVICE_CTRL_RTC_GET_ALARM:
    

  163.         {
    

  164.             struct rt_rtc_wkalarm *alm_time;
    


  165. 

  166.             ret = ds3231_read_reg(dev, REG_ALM1_SEC, buff, 4);
    

  167.             if(ret == RT_EOK)
    

  168.             {
    

  169.                 alm_time = (struct rt_rtc_wkalarm *)args;
    

  170.                 alm_time->tm_hour  = bcd_to_hex(buff[2]);
    

  171.                 alm_time->tm_min   = bcd_to_hex(buff[1]);
    

  172.                 alm_time->tm_sec   = bcd_to_hex(buff[0]);
    

  173.             }
    

  174.         }
    

  175.         break;
    


  176. 

  177.         /* set alarm time */
    

  178.         case RT_DEVICE_CTRL_RTC_SET_ALARM:
    

  179.         {
    

  180.             struct rt_rtc_wkalarm *alm_time;
    


  181. 

  182.             alm_time = (struct rt_rtc_wkalarm *)args;
    

  183.             buff[3] = 0x80; /* enable, alarm when hours, minutes, and seconds match */
    

  184.             buff[2] = hex_to_bcd(alm_time->tm_hour);
    

  185.             buff[1] = hex_to_bcd(alm_time->tm_min);
    

  186.             buff[0] = hex_to_bcd(alm_time->tm_sec);
    

  187.             ret = ds3231_write_reg(dev, REG_ALM1_SEC, buff, 4);
    

  188.         }
    

  189.         break;
    

  190.     #endif
    

  191.         default:
    

  192.         break;
    

  193.     }
    

  194.     return ret;
    

  195. }
    


  196. 

  197. float ds3231_get_temperature(void)
    

  198. {
    

  199.     rt_int8_t buff[2];
    

  200.     float temp = 0.0f;
    


  201. 

  202.     ds3231_read_reg(&ds3231_dev, REG_TEMP_MSB, (rt_uint8_t*)buff, 2);
    

  203.     if(buff[0]&0x80)
    

  204.     {/* negative temperature */
    

  205.         temp = buff[0];
    

  206.         temp -= (buff[1]>>6)*0.25;  /* 0.25C resolution */
    

  207.     }
    

  208.     else
    

  209.     {/* positive temperature */
    

  210.         temp = buff[0];
    

  211.         temp += ((buff[1]>>6)&0x03)*0.25;
    

  212.     }
    


  213. 

  214.     return temp;
    

  215. }
    


  216. 

  217. int rt_hw_ds3231_init(void)
    

  218. {
    

  219.     struct rt_i2c_bus_device *i2c_device;
    

  220.     uint8_t data;
    


  221. 

  222.     i2c_device = rt_i2c_bus_device_find(DS3231_I2C_BUS);
    

  223.     if (i2c_device == RT_NULL)
    

  224.     {
    

  225.         LOG_E("i2c bus device %s not found!\r\n", DS3231_I2C_BUS);
    

  226.         return -RT_ERROR;
    

  227.     }
    


  228. 

  229.     /* register rtc device */
    

  230.     ds3231_dev.type         = RT_Device_Class_RTC;
    

  231.     ds3231_dev.init         = RT_NULL;
    

  232.     ds3231_dev.open         = rt_ds3231_open;
    

  233.     ds3231_dev.close        = RT_NULL;
    

  234.     ds3231_dev.read         = rt_ds3231_read;
    

  235.     ds3231_dev.write        = RT_NULL;
    

  236.     ds3231_dev.control      = rt_ds3231_control;
    

  237.     ds3231_dev.user_data    = (void*)i2c_device;    /* save i2cbus */;
    

  238.     rt_device_register(&ds3231_dev, DS3231_DEVICE_NAME, RT_DEVICE_FLAG_RDWR);
    


  239. 

  240.     /* init ds3231 */
    

  241.     data = 0x04;    /* close clock out */
    

  242.     ds3231_write_reg(&ds3231_dev, REG_CONTROL, &data, 1);
    

  243.     LOG_D("the rtc of ds3231 init succeed!");
    


  244. 

  245.     return 0;
    

  246. }
    

  247. //INIT_DEVICE_EXPORT(rt_hw_ds3231_init);
    

  248. INIT_COMPONENT_EXPORT(rt_hw_ds3231_init);
    


  249. 

  250. #ifdef RT_USING_FINSH
    

  251. #include <finsh.h>
    


  252. 

  253. void list_ds31_temp(void)
    

  254. {
    

  255.     float temp = 0.0f;
    


  256. 

  257.     temp = ds3231_get_temperature();
    


  258. 

  259.     rt_kprintf("ds3231 temperature: [%d.%dC] \n", (int)temp, (int)(temp * 10) % 10);
    

  260. }
    

  261. FINSH_FUNCTION_EXPORT(list_ds31_temp, list ds3231 temperature.)
    

  262. #endif /* RT_USING_FINSH */



2.3 效果验证
7777668d9295ddd073.png
经过验证，可以从ds3231上读取到温度值，说明读取寄存器时正常的。但使用date命令回复的时间没有变化，说明rtthread的rtc框架和ds3231驱动间的衔接有问题。经过排查，发现rtthread的系统代码让先楫改的面目全非，不再支持外部rtc了。
解决方案，不使用rtc框架，直接读取DS3231的寄存器就可以解决。



回复

收藏 举报

相关帖子
 楼主| dirtwillfly 发表于 2025-9-28 13:41 | 显示全部楼层
备用
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

dirtwillfly
个人签名：欢迎进入TI MCU论坛      21ic TI技术交流1群：61549143(已满)，  21ic TI技术交流2群：311421422 我的博客：http://blog.timcu.com/

1199

主题

35121

帖子

1122

粉丝
快速回复 在线客服 返回列表 返回顶部