🌓 切换到窄版

 找回密码
 立即注册
学习《Ai8051U教学视频》发表七集 以上学习心得，送强大的 Ai8051U实验箱
国芯人工智能技术交流网站»32位8051交流社区，车规 AEC-Q100 Grade1 › 技术交流 › QSPI/3组SPI/I2S/I2C，一线制温湿度传感器 › 利用硬件I2C实现高效率无阻塞读写方法 | 还可以 DMA-I2C ...
返回列表 发新帖
查看: 56|回复: 4

利用硬件I2C实现高效率无阻塞读写方法 | 还可以 DMA-I2C

[复制链接]
chen***
  • 打卡等级：初来乍到
  • 打卡总天数：5
  • 最近打卡：2025-08-07 15:25:14
已绑定手机

3

主题

4

回帖

81

积分

注册会员

积分
81
发表于 3 天前 | 显示全部楼层 |阅读模式
I2C读写巨慢, 即使在400kbit/s下, 读写一个字节数据也要花费20多us, 这太慢了, 每读写一次设备的寄存器数据, 还要设备地址和寄存器地址, 又加了两个字节数据, 我就读了个传感器的两个字节数据而已, 动辄还要花费100us的阻塞时间, 这太浪费资源了
针对这个问题, 我利用硬件I2C及中断配合, 实现了这个没有任何阻塞MCU来读写I2C设备的方法, 效率大大提升
单片机采用stc32g8k64, 主频为40Mhz, 读写LDC1612电感涡流传感器为例来测试异步读写I2C数据

  1. /**

  2.  * stc32g8k64 硬件i2c 实现 无阻塞异步执行

  3.  * ldc1612 i2c异步读写测试

  4.  */

  5. #include <STC32G.h>

  6. #include <stdio.h>

  7. #define FOSC 40000000UL // 主频40M

  8. 

  9. void Delay1ms(void) //@40.000MHz

  10. {

  11.   unsigned char data i, j;

  12. 

  13.   i = 39;

  14.   j = 230;

  15.   do

  16.   {

  17.     while (--j)

  18.       ;

  19.   } while (--i);

  20. }

  21. void delay(uint16 ms)

  22. {

  23.   while (ms--)

  24.   {

  25.     Delay1ms();

  26.   }

  27. }

  28. 

  29. // ---------------------- uart1打印测试用 开始----------------------------

  30. bit busy;

  31. char wptr;

  32. char rptr;

  33. char buffer[16];

  34. 

  35. void Uart1_Isr(void) interrupt 4

  36. {

  37.   if (TI)

  38.   {

  39.     TI = 0;

  40.     busy = 0;

  41.   }

  42.   if (RI)

  43.   {

  44.     RI = 0;

  45.     buffer[wptr++] = SBUF;

  46.     wptr &= 0x0f;

  47.   }

  48. }

  49. void Uart1_Init(void) // 1000000bps@40.000MHz

  50. {

  51.   SCON = 0x50;  // 8位数据,可变波特率

  52.   AUXR |= 0x40; // 定时器时钟1T模式

  53.   AUXR &= 0xFE; // 串口1选择定时器1为波特率发生器

  54.   TMOD &= 0x0F; // 设置定时器模式

  55.   TL1 = 0xF6;   // 设置定时初始值

  56.   TH1 = 0xFF;   // 设置定时初始值

  57.   ET1 = 0;      // 禁止定时器中断

  58.   TR1 = 1;      // 定时器1开始计时

  59.   ES = 1;       // 使能串口1中断

  60. }

  61. void UartSend(char dat)

  62. {

  63.   while (busy)

  64.     ;

  65.   busy = 1;

  66.   SBUF = dat;

  67. }

  68. void UartSendStr(char *p)

  69. {

  70.   while (*p)

  71.   {

  72.     UartSend(*p++);

  73.   }

  74. }

  75. 

  76. char sendNumberCharArr[20];

  77. // 实现一个uint32转char的方法

  78. void numberToChar(uint32 number, char *buffer)

  79. {

  80.   char temp[12]; // Maximum digits for uint32 + null terminator

  81.   int i = 0;

  82.   int j = 0;

  83. 

  84.   // Handle zero case

  85.   if (number == 0)

  86.   {

  87.     buffer[0] = '0';

  88.     buffer[1] = '\0';

  89.     return;

  90.   }

  91. 

  92.   // Extract digits in reverse order

  93.   while (number > 0)

  94.   {

  95.     temp[i++] = (number % 10) + '0';

  96.     number /= 10;

  97.   }

  98. 

  99.   // Reverse the string to correct order

  100.   while (i > 0)

  101.   {

  102.     buffer[j++] = temp[--i];

  103.   }

  104.   buffer[j] = '\0'; // Null terminate

  105. }

  106. // ---------------------- uart1打印测试用 结束----------------------------

  107. 

  108. //------------------------------- I2C异步执行栈 开始 -----------------------------

  109. sbit ET4 = IE2 ^ 6;

  110. typedef void (*AsyncFunc)(void);

  111. AsyncFunc AsyncFuncNext_callback = NULL;

  112. // 延时执行下一个任务

  113. void AsyncFuncNext(AsyncFunc callback, uint16 usDelay)

  114. {

  115.   uint16 totalTime = 0xffff - usDelay;

  116.   T4T3M &= ~0x80;

  117.   ET4 = 0;

  118.   T4L = totalTime & 0xff; // 设置定时初始值

  119.   T4H = totalTime >> 8;   // 设置定时初始值

  120.   AsyncFuncNext_callback = callback;

  121.   T4T3M |= 0x80; // 定时器4开始计时

  122.   ET4 = 1;       // 使能中断

  123. }

  124. // 定时器用于异步执行

  125. void Timer4_Init(void) //@40.000MHz

  126. {

  127.   // 1us计时一个数字

  128.   TM4PS = 0x27;   // 设置定时器时钟预分频

  129.   T4T3M |= 0x20;  // 定时器时钟1T模式

  130.   T4L = 0x00;     // 设置定时初始值

  131.   T4H = 0x00;     // 设置定时初始值

  132.   T4T3M &= ~0x80; // 定时器4停止计时

  133.   ET4 = 0;

  134. }

  135. // 定时器4用作异步执行定时器, 延时触发下一步的执行函数

  136. void Timer4_async_next_isr() interrupt 20

  137. {

  138.   T4T3M &= ~0x80;

  139.   ET4 = 0;

  140.   if (AsyncFuncNext_callback != NULL)

  141.   {

  142.     AsyncFuncNext_callback();

  143.   }

  144. }

  145. AsyncFunc I2C_Isr_callback = NULL; // I2C中断回调函数

  146. void I2C_Isr() interrupt 24        // I2C中断

  147. {

  148.   if (I2CMSST & 0x40)

  149.   {

  150.     I2CMSST &= ~0x40; // 清中断标志

  151.     if (I2C_Isr_callback != NULL)

  152.     {

  153.       I2C_Isr_callback();

  154.     }

  155.   }

  156. }

  157. //------------------------------- 异步执行栈 结束 -----------------------------

  158. 

  159. //------------------------------- I2C寄存器操作 开始 --------------------------

  160. void Wait_I2C()

  161. {

  162.   while (!(I2CMSST & 0x40))

  163.     ;

  164.   I2CMSST &= ~0x40;

  165. }

  166. 

  167. uint8 i2c_readRegister16Async_addr = 0;               // readRegister16Async 地址参数

  168. uint8 i2c_readRegister16Async_reg = 0;                // readRegister16Async 寄存器参数

  169. uint8 i2c_readRegister16Async_step = 0;               // readRegister16Async 异步执行步骤

  170. uint16 i2c_readRegister16Async_value = 0;             // readRegister16Async 读取数据返回值

  171. AsyncFunc i2c_readRegister16Async_endCallback = NULL; // readRegister16Async 读取数据完成回调

  172. void i2c_readRegister16Async_timeout()

  173. {

  174.   i2c_readRegister16Async_value = 0;

  175.   i2c_readRegister16Async_step = 0;

  176.   I2C_Isr_callback = NULL;

  177.   I2CMSST = 0x00;

  178.   if (i2c_readRegister16Async_endCallback != NULL)

  179.   {

  180.     i2c_readRegister16Async_endCallback();

  181.   }

  182. }

  183. // I2C异步读取, 16位寄存器

  184. void i2c_readRegister16Async()

  185. {

  186.   if (i2c_readRegister16Async_step == 1)

  187.   {

  188.     I2CTXD = i2c_readRegister16Async_addr << 1; // 发送i2c地址

  189.     I2CMSCR = 0x89;                             // 中断使能, 发送起始信号+设备地址+写信号

  190.     i2c_readRegister16Async_step++;

  191.     AsyncFuncNext(i2c_readRegister16Async_timeout, 200);

  192.     return;

  193.   }

  194.   if (i2c_readRegister16Async_step == 2)

  195.   {

  196.     I2CTXD = i2c_readRegister16Async_reg; // 发送读取寄存器地址

  197.     I2CMSCR = 0x8A;                       // 中断使能,  发送数据命令+接收ACK命令

  198.     i2c_readRegister16Async_step++;

  199.     AsyncFuncNext(i2c_readRegister16Async_timeout, 200);

  200.     return;

  201.   }

  202.   if (i2c_readRegister16Async_step == 3)

  203.   {

  204.     I2CTXD = i2c_readRegister16Async_addr << 1 | 0x01; // 发送i2c地址+读取数据

  205.     I2CMSCR = 0x89;                                    // 中断使能,  发送起始信号+设备地址+写信号

  206.     i2c_readRegister16Async_step++;

  207.     AsyncFuncNext(i2c_readRegister16Async_timeout, 200);

  208.     return;

  209.   }

  210.   if (i2c_readRegister16Async_step == 4)

  211.   {

  212.     I2CMSST = 0x00; // 设置 ACK 信号

  213.     I2CMSCR = 0x8B; // 中断使能, 接收数据命令+发送ACK(0)命令

  214.     i2c_readRegister16Async_step++;

  215.     AsyncFuncNext(i2c_readRegister16Async_timeout, 200);

  216.     return;

  217.   }

  218.   if (i2c_readRegister16Async_step == 5)

  219.   {

  220.     i2c_readRegister16Async_value = I2CRXD;

  221.     i2c_readRegister16Async_value <<= 8;

  222.     I2CMSST = 0x01; // 设置 NAK 信号

  223.     I2CMSCR = 0x8C; // 中断使能, 接收数据命令+发送NAK(1)命令

  224.     i2c_readRegister16Async_step++;

  225.     AsyncFuncNext(i2c_readRegister16Async_timeout, 200);

  226.     return;

  227.   }

  228.   if (i2c_readRegister16Async_step == 6)

  229.   {

  230.     i2c_readRegister16Async_value |= I2CRXD;

  231.     i2c_readRegister16Async_step++;

  232.     I2CMSCR = 0x86; // 中断使能, 发送 STOP 命令

  233.     AsyncFuncNext(i2c_readRegister16Async_timeout, 200);

  234.     return;

  235.   }

  236.   if (i2c_readRegister16Async_step == 7)

  237.   {

  238.     I2C_Isr_callback = NULL;

  239.     i2c_readRegister16Async_step = 0;

  240.     AsyncFuncNext(i2c_readRegister16Async_endCallback, 20);

  241.     return;

  242.   }

  243. }

  244. // 使用异步来读取i2c数据

  245. void i2c_readRegister16Async_start(uint8 addr, uint8 reg, AsyncFunc readEndCallback)

  246. {

  247.   i2c_readRegister16Async_addr = addr;

  248.   i2c_readRegister16Async_reg = reg;

  249.   i2c_readRegister16Async_value = 0;

  250.   i2c_readRegister16Async_step = 1;

  251.   I2C_Isr_callback = i2c_readRegister16Async;

  252.   i2c_readRegister16Async_endCallback = readEndCallback;

  253.   i2c_readRegister16Async();

  254. }

  255. // I2C同步读取, 16位寄存器

  256. uint16 i2c_readRegister16(uint8 addr, uint8 reg)

  257. {

  258.   uint16 readDataValue = 0;

  259. 

  260.   I2CTXD = addr << 1; // 写数据到数据缓冲区

  261.   I2CMSCR = 0x09;     // 发送起始信号+设备地址+写信号

  262.   Wait_I2C();

  263. 

  264.   I2CTXD = reg;   // 写数据到数据缓冲区

  265.   I2CMSCR = 0x0A; // 发送数据命令+接收ACK命令

  266.   Wait_I2C();

  267. 

  268.   I2CTXD = addr << 1 | 0x01; // 发送i2c地址+读取数据

  269.   I2CMSCR = 0x09;            // 发送起始信号+设备地址+写信号

  270.   Wait_I2C();

  271. 

  272.   I2CMSST = 0x00; // 设置 ACK 信号

  273.   I2CMSCR = 0x0B; // 接收数据命令+发送ACK(0)命令

  274.   Wait_I2C();

  275.   readDataValue = I2CRXD;

  276.   readDataValue <<= 8;

  277. 

  278.   I2CMSST = 0x01; // 设置 NAK 信号

  279.   I2CMSCR = 0x0C; // 接收数据命令+发送NAK(1)命令

  280.   Wait_I2C();

  281.   readDataValue |= I2CRXD;

  282. 

  283.   I2CMSCR = 0x06; // 发送 STOP 命令

  284.   Wait_I2C();

  285. 

  286.   return readDataValue;

  287. }

  288. 

  289. uint8 i2c_writeRegister16Async_addr = 0;               // writeRegister16Async 地址参数

  290. uint8 i2c_writeRegister16Async_reg = 0;                // writeRegister16Async 寄存器参数

  291. uint8 i2c_writeRegister16Async_step = 0;               // writeRegister16Async 异步执行步骤

  292. uint16 i2c_writeRegister16Async_value = 0;             // writeRegister16Async 写入数据

  293. AsyncFunc i2c_writeRegister16Async_endCallback = NULL; // writeRegister16Async 读取数据完成回调

  294. // 异步写16位寄存器超时

  295. void i2c_writeRegister16Async_timeout()

  296. {

  297.   i2c_writeRegister16Async_value = 0;

  298.   i2c_writeRegister16Async_step = 0;

  299.   I2C_Isr_callback = NULL;

  300.   I2CMSST = 0x00;

  301.   if (i2c_writeRegister16Async_endCallback != NULL)

  302.   {

  303.     i2c_writeRegister16Async_endCallback();

  304.   }

  305. }

  306. // 异步写16位寄存器

  307. void i2c_writeRegister16Async()

  308. {

  309.   if (i2c_writeRegister16Async_step == 1)

  310.   {

  311.     I2CTXD = i2c_writeRegister16Async_addr << 1; // 写数据到数据缓冲区

  312.     I2CMSCR = 0x89;                              // 发送起始信号+设备地址+写信号

  313.     i2c_writeRegister16Async_step++;

  314.     AsyncFuncNext(i2c_writeRegister16Async_timeout, 200);

  315.     return;

  316.   }

  317.   if (i2c_writeRegister16Async_step == 2)

  318.   {

  319.     I2CTXD = i2c_writeRegister16Async_reg; // 写数据到数据缓冲区

  320.     I2CMSCR = 0x8A;                        // 发送数据命令+接收ACK命令

  321.     i2c_writeRegister16Async_step++;

  322.     AsyncFuncNext(i2c_writeRegister16Async_timeout, 200);

  323.     return;

  324.   }

  325.   if (i2c_writeRegister16Async_step == 3)

  326.   {

  327.     I2CTXD = (i2c_writeRegister16Async_value >> 8) & 0xFF; // 写数据到数据缓冲区

  328.     I2CMSCR = 0x8A;                                        // 发送数据命令+接收ACK命令

  329.     i2c_writeRegister16Async_step++;

  330.     AsyncFuncNext(i2c_writeRegister16Async_timeout, 200);

  331.     return;

  332.   }

  333.   if (i2c_writeRegister16Async_step == 4)

  334.   {

  335.     I2CTXD = i2c_writeRegister16Async_value & 0xFF; // 写数据到数据缓冲区

  336.     I2CMSCR = 0x8A;                                 // 发送数据命令+接收ACK命令

  337.     i2c_writeRegister16Async_step++;

  338.     AsyncFuncNext(i2c_writeRegister16Async_timeout, 200);

  339.     return;

  340.   }

  341.   if (i2c_writeRegister16Async_step == 5)

  342.   {

  343.     I2CMSCR = 0x86; // 发送 STOP 命令

  344.     i2c_writeRegister16Async_step++;

  345.     AsyncFuncNext(i2c_writeRegister16Async_timeout, 200);

  346.     return;

  347.   }

  348.   if (i2c_writeRegister16Async_step == 6)

  349.   {

  350.     I2C_Isr_callback = NULL;

  351.     i2c_writeRegister16Async_step = 0;

  352.     AsyncFuncNext(i2c_writeRegister16Async_endCallback, 20);

  353.     return;

  354.   }

  355. }

  356. // 使用异步来写入i2c数据

  357. void i2c_writeRegister16Async_start(uint8 addr, uint8 reg, uint16 value, AsyncFunc writeEndCallback)

  358. {

  359.   i2c_writeRegister16Async_addr = addr;

  360.   i2c_writeRegister16Async_reg = reg;

  361.   i2c_writeRegister16Async_value = value;

  362.   I2C_Isr_callback = i2c_writeRegister16Async;

  363.   i2c_writeRegister16Async_endCallback = writeEndCallback;

  364.   i2c_writeRegister16Async_step = 1;

  365.   i2c_writeRegister16Async();

  366. }

  367. // 同步写16位寄存器

  368. void i2c_writeRegister16(uint8 addr, uint8 reg, uint16 value)

  369. {

  370.   I2CTXD = addr << 1; // 写数据到数据缓冲区

  371.   I2CMSCR = 0x09;     // 发送起始信号+设备地址+写信号

  372.   Wait_I2C();

  373.   I2CTXD = reg;   // 写数据到数据缓冲区

  374.   I2CMSCR = 0x0A; // 发送数据命令+接收ACK命令

  375.   Wait_I2C();

  376.   I2CTXD = (value >> 8) & 0xFF; // 写数据到数据缓冲区

  377.   I2CMSCR = 0x0A;               // 发送数据命令+接收ACK命令

  378.   Wait_I2C();

  379.   I2CTXD = value & 0xFF; // 写数据到数据缓冲区

  380.   I2CMSCR = 0x0A;        // 发送数据命令+接收ACK命令

  381.   Wait_I2C();

  382.   I2CMSCR = 0x06; // 发送 STOP 命令

  383.   Wait_I2C();

  384. }

  385. //------------------------------- I2C寄存器操作 结束 --------------------------

  386. 

  387. //------------------------------- LDC1612操作 开始 ----------------------------

  388. #define SD_PIN P1_6    // SD引脚

  389. #define INTB_PIN P1_7  // 数据就绪中断

  390. #define CLKIN_PIN P1_3 // 外部时钟引脚

  391. 

  392. // LDC1612 寄存器地址

  393. #define LDC1612_ADDR 0x2A           // I2C地址 (ADDR接地时)

  394. #define REG_DATA_MSB_CH0 0x00       // 通道0数据高16位

  395. #define REG_DATA_LSB_CH0 0x01       // 通道0数据低16位

  396. #define REG_DATA_MSB_CH1 0x02       // 通道1数据高16位

  397. #define REG_DATA_LSB_CH1 0x03       // 通道1数据低16位

  398. #define REG_RCOUNT_CH0 0x08         // 通道0转换计数

  399. #define REG_RCOUNT_CH1 0x09         // 通道1转换计数

  400. #define REG_SETTLE_CNT_CH0 0x10     // 通道0稳定计数

  401. #define REG_SETTLE_CNT_CH1 0x11     // 通道1稳定计数

  402. #define REG_CLOCK_DIVIDERS_CH0 0x14 // 通道0时钟分频

  403. #define REG_CLOCK_DIVIDERS_CH1 0x15 // 通道1时钟分频

  404. #define REG_STATUS 0x18             // 状态寄存器

  405. #define REG_ERROR_CONFIG 0x19       // 错误配置

  406. #define REG_CONFIG 0x1A             // 配置寄存器

  407. #define REG_MUX_CONFIG 0x1B         // 多路复用配置

  408. #define REG_RESET_DEV 0x1C          // 设备复位

  409. #define REG_DRIVE_CURRENT_CH0 0x1E  // 通道0驱动电流

  410. #define REG_DRIVE_CURRENT_CH1 0x1F  // 通道1驱动电流

  411. 

  412. // 配置常量

  413. #define CONVERSION_TIME 0x0850 // 转换时间设置

  414. #define SETTLE_TIME 0x0400     // 稳定时间设置

  415. #define CLOCK_DIVIDER 0x1001   // 时钟分频设置

  416. #define DRIVE_CURRENT 0x1C00   // 驱动电流设置 (最大电流)

  417. // 全局变量

  418. uint32 ch0_value = 0;

  419. uint32 ch1_value = 0;

  420. uint8 LDC1612_read_ready = 0;

  421. uint8 LDC1612_data_ready = 0;

  422. 

  423. uint16 LDC1612_readDataAsync_msb = 0;

  424. uint16 LDC1612_readDataAsync_lsb = 0;

  425. uint16 LDC1612_readDataAsync_step = 0;

  426. uint8 LDC1612_readDataAsync_isStart = 0;

  427. // 异步读取传感器数据

  428. void LDC1612_readDataAsync()

  429. {

  430.   if (LDC1612_readDataAsync_step == 1)

  431.   {

  432.     LDC1612_readDataAsync_step++;

  433.     AsyncFuncNext(LDC1612_readDataAsync, 100);

  434.     i2c_readRegister16Async_start(LDC1612_ADDR, REG_STATUS, LDC1612_readDataAsync);

  435.     return;

  436.   }

  437.   if (LDC1612_readDataAsync_step == 2)

  438.   {

  439.     LDC1612_readDataAsync_step++;

  440.     i2c_readRegister16Async_start(LDC1612_ADDR, REG_DATA_MSB_CH0, LDC1612_readDataAsync);

  441.     return;

  442.   }

  443.   if (LDC1612_readDataAsync_step == 3)

  444.   {

  445.     LDC1612_readDataAsync_step++;

  446.     LDC1612_readDataAsync_msb = i2c_readRegister16Async_value;

  447.     i2c_readRegister16Async_start(LDC1612_ADDR, REG_DATA_LSB_CH0, LDC1612_readDataAsync);

  448.     return;

  449.   }

  450.   if (LDC1612_readDataAsync_step == 4)

  451.   {

  452.     LDC1612_readDataAsync_step = 0;

  453.     LDC1612_readDataAsync_lsb = i2c_readRegister16Async_value;

  454.     ch0_value = ((uint32)LDC1612_readDataAsync_msb << 16) | LDC1612_readDataAsync_lsb;

  455.     ch0_value &= 0x0FFFFFFF; // 保留28位有效数据

  456.     ch0_value >>= 12;        // 转为16位数据

  457.     LDC1612_data_ready = 1;  // 读取数据完成

  458.     return;

  459.   }

  460. }

  461. // 同步读取传感器数据

  462. void LDC1612_readData()

  463. {

  464.   uint16 msb = 0;

  465.   uint16 lsb = 0;

  466.   // 读取状态寄存器

  467.   uint16 status = i2c_readRegister16(LDC1612_ADDR, REG_STATUS);

  468.   // 检查错误标志

  469.   if (status & 0x0008)

  470.   {

  471.     // Serial.println("Error: Amplitude too low!");

  472.   }

  473.   if (status & 0x0010)

  474.   {

  475.     // Serial.println("Error: Timeout occurred!");

  476.   }

  477. 

  478.   // 读取通道0数据

  479.   msb = i2c_readRegister16(LDC1612_ADDR, REG_DATA_MSB_CH0);

  480.   lsb = i2c_readRegister16(LDC1612_ADDR, REG_DATA_LSB_CH0);

  481.   ch0_value = ((uint32)msb << 16) | lsb;

  482.   ch0_value &= 0x0FFFFFFF; // 保留28位有效数据

  483.   ch0_value >>= 12;

  484.   LDC1612_data_ready = 1; // 读取数据完成

  485. }

  486. 

  487. uint8 LDC1612_writeInitReg_step = 0;

  488. // 异步方法写入寄存器值

  489. void LDC1612_writeInitRegAsync()

  490. {

  491.   // 配置通道0

  492.   if (LDC1612_writeInitReg_step == 1)

  493.   {

  494.     LDC1612_writeInitReg_step++;

  495.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_RCOUNT_CH0, CONVERSION_TIME, LDC1612_writeInitRegAsync);

  496.     return;

  497.   }

  498.   if (LDC1612_writeInitReg_step == 2)

  499.   {

  500.     LDC1612_writeInitReg_step++;

  501.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_SETTLE_CNT_CH0, SETTLE_TIME, LDC1612_writeInitRegAsync);

  502.     return;

  503.   }

  504.   if (LDC1612_writeInitReg_step == 3)

  505.   {

  506.     LDC1612_writeInitReg_step++;

  507.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_CLOCK_DIVIDERS_CH0, CLOCK_DIVIDER, LDC1612_writeInitRegAsync);

  508.     return;

  509.   }

  510.   if (LDC1612_writeInitReg_step == 4)

  511.   {

  512.     LDC1612_writeInitReg_step++;

  513.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_DRIVE_CURRENT_CH0, DRIVE_CURRENT, LDC1612_writeInitRegAsync);

  514.     return;

  515.   }

  516.   // 配置错误检测

  517.   if (LDC1612_writeInitReg_step == 5)

  518.   {

  519.     LDC1612_writeInitReg_step++;

  520.     // 启用数据输出错误检测

  521.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_ERROR_CONFIG, 0x0001, LDC1612_writeInitRegAsync);

  522.     return;

  523.   }

  524.   // 配置多路复用器 - 只启用通道0

  525.   if (LDC1612_writeInitReg_step == 6)

  526.   {

  527.     LDC1612_writeInitReg_step++;

  528.     // 只扫描通道0，去抖动计数=1

  529.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_MUX_CONFIG, 0x0208, LDC1612_writeInitRegAsync);

  530.     return;

  531.   }

  532.   // 配置主配置寄存器

  533.   if (LDC1612_writeInitReg_step == 7)

  534.   {

  535.     LDC1612_writeInitReg_step++;

  536.     // 启用传感器，单通道模式

  537.     i2c_writeRegister16Async_start(LDC1612_ADDR, REG_CONFIG, 0x1401, LDC1612_writeInitRegAsync);

  538.     return;

  539.   }

  540.   // 初始化完成

  541.   if (LDC1612_writeInitReg_step == 8)

  542.   {

  543.     LDC1612_writeInitReg_step = 0;

  544.     return;

  545.   }

  546. }

  547. // 同步方法写入寄存器值

  548. void LDC1612_writeInitReg()

  549. {

  550.   // 配置通道0

  551.   i2c_writeRegister16(LDC1612_ADDR, REG_RCOUNT_CH0, CONVERSION_TIME);

  552.   i2c_writeRegister16(LDC1612_ADDR, REG_SETTLE_CNT_CH0, SETTLE_TIME);

  553.   i2c_writeRegister16(LDC1612_ADDR, REG_CLOCK_DIVIDERS_CH0, CLOCK_DIVIDER);

  554.   i2c_writeRegister16(LDC1612_ADDR, REG_DRIVE_CURRENT_CH0, DRIVE_CURRENT);

  555. 

  556.   // 配置错误检测

  557.   i2c_writeRegister16(LDC1612_ADDR, REG_ERROR_CONFIG, 0x0001); // 启用数据输出错误检测

  558. 

  559.   // 配置多路复用器 - 只启用通道0

  560.   i2c_writeRegister16(LDC1612_ADDR, REG_MUX_CONFIG, 0x0208); // 只扫描通道0，去抖动计数=1

  561. 

  562.   // 配置主配置寄存器

  563.   i2c_writeRegister16(LDC1612_ADDR, REG_CONFIG, 0x1401); // 启用传感器，单通道模式

  564. }

  565. 

  566. // LDC1612 中断服务程序 (数据就绪)

  567. void LDC1612_ready_isr() interrupt 38

  568. {

  569.   unsigned char intf;

  570.   intf = P1INTF;

  571.   if (intf)

  572.   {

  573.     P1INTF = 0x00;

  574.     // P1.7 口中断

  575.     if (intf & 0x80)

  576.     {

  577.       LDC1612_read_ready = 1;

  578.     }

  579.   }

  580. }

  581. 

  582. void initI2C()

  583. {

  584.   P_SW2 = 0x80; // 使能访问XFR

  585.   P1PU |= 0x30; // P1.4和P1.5使能4K上拉电阻

  586.   P1M1 |= 0x10;

  587.   P1M0 |= 0x10; // P1.4(SDA)开漏输出

  588.   P1M1 |= 0x20;

  589.   P1M0 |= 0x20; // P1.5(SCL)开漏输出

  590. 

  591.   // I2C总线速度计算: SYSCLK / 2 / (MSSPEED * 2 + 4)

  592.   // 对于400KHz: MSSPEED = (40M / 400K / 2 - 4) / 2 = 23 (0x17)

  593.   I2CCFG = 0x80 | 0x40 | 0x17; // 使能I2C + 主机模式 + 400KHz速度

  594.   I2CMSST = 0x00;              // 清除状态寄存器

  595.   IP2H |= 0x40;                // 设置I2c中断的优先级为高

  596.   IP2 |= 0x40;                 // 设置I2c中断的优先级为高

  597. }

  598. 

  599. // LDC1612初始化

  600. void initLDC1612()

  601. {

  602.   // p1.6 SD

  603.   P1M1 &= ~0x40;

  604.   P1M0 |= 0x40; // 推挽输出

  605.   // p1.3 CLKIN_PIN

  606.   P1M1 &= ~0x08;

  607.   P1M0 |= 0x08; // 推挽输出

  608.   // p1.7 INTB 数据准备好中断

  609.   P1M1 |= 0x80;

  610.   P1M0 &= ~0x80; // 高阻输入

  611. 

  612.   SD_PIN = 0;    // 低电平使能ldc1612

  613.   CLKIN_PIN = 0; // 禁用外部时钟引脚

  614.   P1IM0 = 0x00;  // 下降沿中断

  615.   P1IM1 = 0x00;

  616.   P1INTE = 0x80; // 使能 p1.7 口中断

  617. 

  618.   Timer4_Init();

  619.   initI2C();

  620.   delay(50);

  621. 

  622.   // 同步方法写入寄存器

  623.   // LDC1612_writeInitReg();

  624.   // 异步方式写入寄存器

  625.   LDC1612_writeInitReg_step = 1;

  626.   LDC1612_writeInitRegAsync();

  627. }

  628. //------------------------------- LDC1612操作 结束 ----------------------------

  629. 

  630. void main(void)

  631. {

  632.   P_SW2 = 0x80; // 使能访问XFR

  633.   WTST = 0;     // 设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快

  634.   CKCON = 0;    // 提高访问XRAM速度

  635. 

  636.   Uart1_Init(); // 初始化串口 1M波特率

  637.   EA = 1;       // 允许总中断

  638.   initLDC1612();

  639.   UartSendStr("setup\n");

  640. 

  641.   while (1)

  642.   {

  643.     if (LDC1612_read_ready == 1)

  644.     {

  645.       LDC1612_read_ready = 0;

  646.       // 同步读取传感器数据

  647.       // LDC1612_readData();

  648. 

  649.       // i2c无阻塞异步读取传感器数据

  650.       LDC1612_readDataAsync_step = 1;

  651.       LDC1612_readDataAsync();

  652.     }

  653. 

  654.     if (LDC1612_data_ready == 1)

  655.     {

  656.       LDC1612_data_ready = 0;

  657.       UartSendStr("LDC1612 data:");

  658.       numberToChar(ch0_value, sendNumberCharArr);

  659.       UartSendStr(sendNumberCharArr);

  660.       UartSendStr("\n");

  661.     }

  662.   }

  663. }

复制代码





回复

使用道具 举报 送花
神***
  • 打卡等级：常住居民III
  • 打卡总天数：152
  • 最近打卡：2025-08-08 08:22:43

766

主题

1万

回帖

1万

积分

管理员

积分
18594
发表于 前天 08:21 | 显示全部楼层
还可以 DMA-I2C
回复 支持 反对

使用道具 举报 送花
chen***
  • 打卡等级：初来乍到
  • 打卡总天数：5
  • 最近打卡：2025-08-07 15:25:14
已绑定手机

3

主题

4

回帖

81

积分

注册会员

积分
81
发表于 前天 09:31 | 显示全部楼层
神*** 发表于 2025-8-6 08:21
还可以 DMA-I2C
我看官方的demo读取数据时,
DMA-I2C在发送设备地址和寄存器地址时还是是阻塞的,
后边的数据传输是启动的DMA,
写入时可以全部使用DMA来操作, 我试试

screenshot-20250806-092927.png

点评

erci***
这个是硬件外设的查询模式，不是DMA阻塞 [attachimg]110877[/attachimg]  详情 回复 发表于 前天 23:37
回复 支持 反对

使用道具 举报 送花
erci***
  • 打卡等级：以坛为家I
  • 打卡总天数：261
  • 最近打卡：2025-08-08 08:57:29
已绑定手机

78

主题

2819

回帖

5829

积分

荣誉版主

无情的代码机器

积分
5829
发表于 前天 23:37 | 显示全部楼层
chen*** 发表于 2025-8-6 09:31
我看官方的demo读取数据时,
DMA-I2C在发送设备地址和寄存器地址时还是是阻塞的,
后边的数据传输是启动的D ...

这个是硬件外设的查询模式，不是DMA阻塞

截图202508062337219727.jpg
三天不学习，赶不上刘少奇~
回复 支持 反对

使用道具 举报 送花
chen***
  • 打卡等级：初来乍到
  • 打卡总天数：5
  • 最近打卡：2025-08-07 15:25:14
已绑定手机

3

主题

4

回帖

81

积分

注册会员

积分
81
发表于 昨天 15:25 | 显示全部楼层
erci*** 发表于 2025-8-6 23:37
这个是硬件外设的查询模式，不是DMA阻塞

我知道这是查询模式清零的, I2C读取数据之前得需要先写入设备地址和寄存器地址, 后面的读取数据是走dma,没有阻塞, 但是开头需要先发送设备地址和寄存器地址, 按照这样写的话, 就又成为阻塞形式了, 期间cpu啥也干不了, 我想要的是没有任何while死循环的零阻塞I2C数据读写
回复 支持 反对

使用道具 举报 送花
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|深圳国芯人工智能有限公司 ( 粤ICP备2022108929号-2 )

GMT+8, 2025-8-8 15:30 , Processed in 0.126655 second(s), 77 queries .

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表