学习目标

  1. 掌握I2C配置方式
  2. 掌握I2C读写操作

    学习内容

    需求

    开发板中的PCF8563的RTC时钟设置和读取。
    214.png215.png

    I2C功能配置

    055.png
    选择对应的I2C，打开。
    056.png
    057.png
    配置完成后可以查询引脚是否符合要求。

I2C编码

移植PCF8563驱动

  1. #ifndef __PCF8563_H__
  2. #define __PCF8563_H__
  4. #include "stm32f4xx.h"
  5. #include "i2c.h"
  7. #ifndef u8
  8. #define u8 uint8_t
  9. #endif
  11. #ifndef u16
  12. #define u16 uint16_t
  13. #endif
  15. // 如果定义了该宏，Alarm的相关函数才会被编译并启用，被注释掉就是禁用
  16. //#define PCF8563_ALARM_ENABLE
  17. // 如果定义了该宏，Timer的相关函数才会被编译并启用，被注释掉就是禁用
  18. //#define PCF8563_TIMER_ENABLE
  20. // 设备地址
  21. #define        PCF8563_ADDR  0x51
  22. // 存储地址：时间的存储地址开始位置
  23. #define        PCF8563_REG_TD   0x02
  25. // 控制寄存器2
  26. #define        PCF8563_REG_CS2   0x01
  28. // I2C写操作
  29. #define     I2C_WRITE(a, r, p, n)        I2C1_write(a, r, p, n)
  30. // I2C读操作
  31. #define     I2C_READ(a, r, p, n)        I2C1_read(a, r, p, n)
  34. // 秒、分、时、星期、日、月、年、世纪
  35. // year = 2023, month = 2, day = 28, week = 4;
  36. // hour = 23, minute = 59, second = 52;
  37. typedef struct {
  39.     u16 year;
  40.     u8 month;
  41.     u8 day;
  42.     u8 week;
  43.     u8 hour;
  44.     u8 minute;
  45.     u8 second;
  47. } Clock_t;
  49. // 警报、闹铃Alarm结构体
  50. typedef struct {
  51.     u8 minute;
  52.     u8 hour;
  53.     u8 day;
  54.     u8 weekday;
  55. } Alarm_t;
  57. typedef enum {
  59.     HZ4096 = 0,
  60.     HZ64     = 1,
  61.     HZ1          = 2,
  62.     HZ1_60 = 3,
  63. }TimerFreq;
  66. void PCF8563_init();
  68. void PCF8563_set_clock(Clock_t c);
  70. void PCF8563_get_clock(Clock_t *c);
  72. void PCF8563_set_alarm(Alarm_t alarm);
  73. void PCF8563_enable_alarm();
  74. void PCF8563_disable_alarm();
  75. void PCF8563_alarm_clear_flag();
  77. void PCF8563_set_timer(TimerFreq freq ,u8 countdown);
  78. void PCF8563_enable_timer();
  79. void PCF8563_disable_timer();
  80. void PCF8563_timer_clear_flag();
  82. #ifdef PCF8563_ALARM_ENABLE
  83. extern void PCF8563_on_alarm();
  84. #endif
  86. #ifdef PCF8563_TIMER_ENABLE
  87. extern void PCF8563_on_timer();
  88. #endif
  90. #endif
  1. #include "PCF8563.h"
  2. #include <stdio.h>
  4. #define NUMBER_TD    7
  6. void PCF8563_init() {
  8. }
  10. void PCF8563_set_clock(Clock_t c) {
  12.     u8 p[NUMBER_TD];                // 用于存储时间字节数组
  13.     u8 Cent; // 世纪：0代表本世纪20, 1代表下个世纪，年99->00时交替
  15.     // 将数值转成一个字节表达 (BCD)
  17.     // 秒：VL 1 1 1 - 0 0 0 0
  18.     p[0] = ((c.second / 10) << 4) + (c.second % 10);
  20.     // 分： X 1 1 1 - 0 0 0 0
  21.     p[1] = ((c.minute / 10) << 4) + (c.minute % 10);
  23.     // 时： X X 1 1 - 0 0 0 0
  24.     p[2] = ((c.hour / 10) << 4) + (c.hour % 10);
  26.     // 天： X X 1 1 - 0 0 0 0
  27.     p[3] = ((c.day / 10) << 4) + (c.day % 10);
  29.     // 周： X X X X - X 0 0 0
  30.     p[4] = c.week;
  32.     // 世纪 20xx , 21xx
  33.     Cent = (c.year >= 2100 ? 1 : 0);
  34.     // 月： C X X 1 - 0 0 0 0
  35.     p[5] = (Cent << 7) + ((c.month / 10) << 4) + (c.month % 10);
  37.     // 年： 1 1 1 1 - 0 0 0 0   2023, 2036
  38.     p[6] = ((c.year % 100 / 10) << 4) + (c.year % 10);
  40.     // 设置数据Write
  41.     I2C_WRITE(PCF8563_ADDR, PCF8563_REG_TD, p, NUMBER_TD);
  42. }
  44. void PCF8563_get_clock(Clock_t *c) {
  46.     u8 Cent; // 世纪：0代表本世纪20, 1代表下个世纪，年99->00时交替
  47.     u8 p[NUMBER_TD];                // 用于存储时间字节数组
  48.     // 循环读取Read: 秒、分、时、星期、日、月、年、世纪
  49.     I2C_READ(PCF8563_ADDR, PCF8563_REG_TD, p, NUMBER_TD);
  51. //            for(i = 0; i < NUMBER; i++){
  52. //                printf("%d-> %d \n", (int)i, (int)p[i]);
  53. //            }
  54. //            printf("----------------\n");
  55.     // 秒：VL 1 1 1 - 0 0 0 0 转成十进制
  56.     c->second = ((p[0] >> 4) & 0x07) * 10 + (p[0] & 0x0F);
  58.     // 分： X 1 1 1 - 0 0 0 0 转成十进制
  59.     c->minute = ((p[1] >> 4) & 0x07) * 10 + (p[1] & 0x0F);
  61.     // 时： X X 1 1 - 0 0 0 0 转成十进制
  62.     c->hour     = ((p[2] >> 4) & 0x03) * 10 + (p[2] & 0x0F);
  64.     // 天： X X 1 1 - 0 0 0 0 转成十进制
  65.     c->day      = ((p[3] >> 4) & 0x03) * 10 + (p[3] & 0x0F);
  67.     // 周： X X X X - X 0 0 0 转成十进制
  68.     c->week      = p[4] & 0x07;
  70.     // 世纪
  71.     // 月： C X X 1 - 0 0 0 0
  72.     c->month     = ((p[5] >> 4) & 0x01) * 10 + (p[5] & 0x0F);
  73.     Cent          = p[5] >> 7;        // 0->20xx年 1->21xx年
  75.     // 年： 1 1 1 1 - 0 0 0 0   1969, 2023
  76.     c->year   = ((p[6] >> 4) & 0x0F) * 10 + (p[6] & 0x0F);
  77.     c->year    += Cent == 0 ? 2000 : 2100;
  78. }
  81. void PCF8563_set_alarm(Alarm_t alarm){
  82.         // 想将某个类型关闭掉，传一个负数
  83.         // 或者多传1个字段，低4位，根据01决定是否启动对应类型 0000 0011
  85.     u8 a[4];
  86. //        a = 0;    // 分钟
  87. //        I2C_WRITE(PCF8563_ADDR, 0x09, &a, 1);
  88. //
  89. //        a = 0;    // 小时
  90. //        I2C_WRITE(PCF8563_ADDR, 0x0A, &a, 1);
  92.     // 分 M    1 1 1 - 0 0 0 0            enable->0, diabled->0x80
  93.     a[0] = ((alarm.minute / 10) << 4) + (alarm.minute % 10) + 0;
  95.     // 时 H    x 1 1 - 0 0 0 0            enable->0, diabled->0x80
  96.     a[1] = ((alarm.hour / 10) << 4) + (alarm.hour % 10) + 0;
  98.     // 天 D    x 1 1 - 0 0 0 0            enable->0, diabled->0x80
  99.     a[2] = ((alarm.day / 10) << 4) + (alarm.day % 10) + 0;
  101.     // 周 W x x x - x 0 0 0            enable->0, diabled->0x80
  102.     a[3] = alarm.weekday + 0;
  104.     I2C_WRITE(PCF8563_ADDR, 0x09, a, 4);
  105. }
  107. void PCF8563_enable_alarm(){
  108.     u8 cs2 = 0; // 控制状态寄存器2
  109.         // 配置 cs2 寄存器以启用Alarm -------------------------------------------------
  110.     I2C_READ(PCF8563_ADDR, 0x01, &cs2, 1);
  111.         // printf("cs2: %d \n", (int)cs2);
  112.     // 清除Alarm标记，AF设置为0，下一次闹钟到点时，才能触发
  113.     cs2 &= ~0x08;
  114.     // 开启Alarm中断, AIE为1，启用Alarm闹钟
  115.     cs2 |= 0x02;
  116.     I2C_WRITE(PCF8563_ADDR, 0x01, &cs2, 1);
  117. }
  118. void PCF8563_disable_alarm(){
  119.     u8 cs2 = 0; // 控制状态寄存器2
  120.         // 配置 cs2 寄存器以启用Alarm -------------------------------------------------
  121.     I2C_READ(PCF8563_ADDR, 0x01, &cs2, 1);
  122.         // printf("cs2: %d \n", (int)cs2);
  123.     // 清除Alarm标记，AF设置为0，下一次闹钟到点时，才能触发
  124.     cs2 &= ~0x08;
  125.     // 开启Alarm中断, AIE为0，禁用Alarm闹钟
  126.     cs2 &= ~0x02;
  127.     I2C_WRITE(PCF8563_ADDR, 0x01, &cs2, 1);
  128. }
  129. void PCF8563_alarm_clear_flag(){
  131.     u8 cs2 = 0; // 控制状态寄存器2
  132.     // 01H寄存器中AF位，会在Alarm触发时，被置为1.
  133.     // 必须手动置为0，下一个Alarm才能触发。
  135.     // 配置 cs2 寄存器
  136.     I2C_READ(PCF8563_ADDR, 0x01, &cs2, 1);
  137. //        printf("cs2: %d \n", (int)cs2);
  138.     // 清除Alarm标记，AF设置为0，下一次闹钟到点时，才能触发
  139.     cs2 &= ~0x08;
  140.     I2C_WRITE(PCF8563_ADDR, 0x01, &cs2, 1);
  141. }
  143. void PCF8563_set_timer(TimerFreq freq ,u8 countdown){
  144.         u8 p = 0;
  145.         // 设置Timer运行频率、启用timer source clock
  146.         p = 0x80 + freq; // 64Hz
  147.         I2C_WRITE(PCF8563_ADDR, 0x0E, &p, 1);
  149.         // 设置Timer计数值(每个周期)
  150.         p = countdown;
  151.         I2C_WRITE(PCF8563_ADDR, 0x0F, &p, 1);
  153. }
  155. void PCF8563_enable_timer(){
  156.     u8 cs2 = 0; // 控制状态寄存器2
  157.         // 通过cs2启用Timer
  158.         I2C_READ(PCF8563_ADDR, 0x01, &cs2, 1);
  159.         // 开启Timer中断：     TIE
  160.         cs2 |=  0x01;
  161.         // 清除Timer flag； TF
  162.         cs2 &= ~0x04;
  163.         I2C_WRITE(PCF8563_ADDR, 0x01, &cs2, 1);
  164. }
  166. void PCF8563_disable_timer(){
  167.     u8 cs2 = 0; // 控制状态寄存器2
  168.         // 通过cs2启用Timer
  169.         I2C_READ(PCF8563_ADDR, 0x01, &cs2, 1);
  170.         // 开启Timer中断：     TIE
  171.         cs2 &= ~0x01;
  172.         // 清除Timer flag； TF
  173.         cs2 &= ~0x04;
  174.         I2C_WRITE(PCF8563_ADDR, 0x01, &cs2, 1);
  175. }
  177. void PCF8563_timer_clear_flag(){
  178.     u8 cs2 = 0; // 控制状态寄存器2
  179.         // 通过cs2启用Timer
  180.         I2C_READ(PCF8563_ADDR, 0x01, &cs2, 1);
  181.         // 清除Timer flag； TF
  182.         cs2 &= ~0x04;
  183.         I2C_WRITE(PCF8563_ADDR, 0x01, &cs2, 1);
  184. }
  187. // 当中断触发时，此函数会执行（Alarm、Timer）
  188. void ext_int3_call() {
  189.         u8 cs2;
  190.         I2C_READ(PCF8563_ADDR, PCF8563_REG_CS2, &cs2, 1);
  191. //        printf("cs2: %d \n", (int) cs2);
  194. #ifdef PCF8563_TIMER_ENABLE
  195.         // Alarm Flag && AIE
  196.         if((cs2 & 0x08) && (cs2 & 0x02)){
  197.                 // 清除Alarm标记，避免下次无法触发
  198.                 PCF8563_alarm_clear_flag();
  199.                 // 事件触发
  200.                 PCF8563_on_alarm();
  201.         }
  202. #endif
  204. #ifdef PCF8563_TIMER_ENABLE
  205.         // Timer Flag && TIE
  206.         if((cs2 & 0x04) && (cs2 & 0x01)){
  207.                 // 清除Timer标记，避免下次无法触发
  208.                 PCF8563_timer_clear_flag();
  209.                 // 事件触发
  210.                 PCF8563_on_timer();
  211.         }
  212. #endif
  213. }

只需要实现 i2c_write和i2c_read，驱动就可以正常运行。

  1. /* USER CODE BEGIN WHILE */
  2. // pcf8563初始化
  3. PCF8563_init();
  5. Clock_t c;
  6. c.year = 2023;
  7. c.month = 3;
  8. c.day = 10;
  9. c.week = 2;
  10. c.hour = 23;
  11. c.minute = 59;
  12. c.second = 55;
  13. PCF8563_set_clock(c);
  15. while (1)
  16. {
  17.     PCF8563_get_clock(&c);
  18.     printf("%d-%d-%d %d %d:%d:%d\r\n", c.year, c.month, c.day, c.week, c.hour, c.minute,c.second);
  19.     HAL_Delay(1000);
  20.     /* USER CODE END WHILE */
  22.     /* USER CODE BEGIN 3 */
  23. }
  24. /* USER CODE END 3 */

I2C读写实现

添加头定义

  1. /* USER CODE BEGIN Prototypes */
  2. void I2C1_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
  3. void I2C1_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
  5. /* USER CODE END Prototypes */

添加c实现

  1. /* USER CODE BEGIN 1 */
  2. #include "string.h"
  3. void I2C1_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
  4.     uint8_t buff[len + 1];
  5.     buff[0] = reg;
  6.     memcpy(&buff[1], data, len);
  7.     HAL_I2C_Master_Transmit(&hi2c1, addr << 1, buff, len + 1, HAL_MAX_DELAY);
  8. }
  9. void I2C1_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
  10.     HAL_I2C_Master_Transmit(&hi2c1, addr << 1, &reg, 1, HAL_MAX_DELAY);
  11.     HAL_I2C_Master_Receive(&hi2c1, (addr << 1) | 0x01, data, len, HAL_MAX_DELAY);
  12. }
  13. /* USER CODE END 1 */
  • HAL库的设备地址，要的是具体的读写地址。
  • HAL库中的写操作中的数据，包含了寄存器地址。
  • HAL库中读操作，需要先写再读。

    练习题

  1. 使用HAL库读写PCF8563芯片