基于aithinker_Ai-M6X_SDK的I2C封装

                               
登录/注册后可看大图

目前aithinker_Ai-M6X_SDK 使用I2C 不是很友好。所以参考其他封装代码修改成适配SDK的封装代码。

Wire.h

1. #pragma once
   
2. 
   
3. // #include "bouffalo_sdk.h"
   
4. #include "bflb_gpio.h"
   
5. #include "bl616_gpio.h"
   
6. #include "bl616_glb.h"
   
7. #include "bl616_glb_gpio.h"
   
8. #include "../../drivers/lhal/include/hardware/i2c_reg.h"
   
9. #include "bflb_i2c.h"
   
10. #define lowByte(w) ((uint8_t) ((w) & 0xff))
    
11. #define highByte(w) ((uint8_t) ((w) >> 8))
    
12. 
    
13. bool getWireTimeoutFlag();
    
14. bool clearWireTimeoutFlag();
    
15. void setWireTimeout(int timeout, bool reset_on_timeout);
    
16. void onRequest(void (*callback)());
    
17. void onReceive(void (*callback)(int));
    
18. void setClock(int clockFrequency);
    
19. int readI2c();
    
20. int available();
    
21. int write_len(uint8_t *str, int len);
    
22. int write_str(uint8_t *str);
    
23. int write_char(unsigned char value);
    
24. void endTransmission_stop(bool stop);
    
25. void endTransmission();
    
26. void beginTransmission(unsigned char addr);
    
27. int requestFrom_stop(unsigned char addr, int quantity, bool stop);
    
28. int requestFrom(unsigned char addr, int quantity);
    
29. void end();
    
30. void begin_addr(unsigned char addr);
    
31. void begin();

复制代码

Wire.c

1. #include "Wire.h"
   
2. 
   
3. #define PUT_UINT32_LE(field, value)            \
   
4.     do {                                       \
   
5.         (field)[0] = (uint8_t)((value) >> 0);  \
   
6.         (field)[1] = (uint8_t)((value) >> 8);  \
   
7.         (field)[2] = (uint8_t)((value) >> 16); \
   
8.         (field)[3] = (uint8_t)((value) >> 24); \
   
9.     } while (0)
   
10. 
    
11. 
    
12. 
    
13. struct bflb_device_s *i2c0;
    
14. uint8_t rbuf[128];
    
15. int available_count;
    
16. int indexi2c;
    
17. int wire_timeout;
    
18. bool wire_timeout_flag;
    
19. 
    
20. void board_i2c_pinmux_init(void)
    
21. {
    
22.     GLB_GPIO_Type pinlist[] = {
    
23.         GLB_GPIO_PIN_30,
    
24.         GLB_GPIO_PIN_31
    
25.     };
    
26.     GLB_GPIO_Func_Init(GPIO_FUN_I2C0, pinlist, 2);
    
27. }
    
28. 
    
29. bool bflb_i2c_isend(struct bflb_device_s *dev)
    
30. {
    
31.     uint32_t regval;
    
32.     uint32_t reg_base;
    
33. 
    
34.     reg_base = dev->reg_base;
    
35. 
    
36.     regval = getreg32(reg_base + I2C_INT_STS_OFFSET);
    
37. 
    
38.     if (regval & I2C_END_INT) {
    
39.         return true;
    
40.     }
    
41. 
    
42.     return false;
    
43. }
    
44. 
    
45. bool bflb_i2c_isnak(struct bflb_device_s *dev)
    
46. {
    
47.     uint32_t regval;
    
48.     uint32_t reg_base;
    
49. 
    
50.     reg_base = dev->reg_base;
    
51. 
    
52.     regval = getreg32(reg_base + I2C_INT_STS_OFFSET);
    
53. 
    
54.     if (regval & I2C_NAK_INT) {
    
55.         return true;
    
56.     }
    
57. 
    
58.     return false;
    
59. }
    
60. 
    
61. bool bflb_i2c_isbusy(struct bflb_device_s *dev)
    
62. {
    
63.     uint32_t regval;
    
64.     uint32_t reg_base;
    
65. 
    
66.     reg_base = dev->reg_base;
    
67. 
    
68.     regval = getreg32(reg_base + I2C_BUS_BUSY_OFFSET);
    
69. 
    
70.     if (regval & I2C_STS_I2C_BUS_BUSY) {
    
71.         return true;
    
72.     }
    
73. 
    
74.     return false;
    
75. }
    
76. 
    
77. void bflb_i2c_enable(struct bflb_device_s *dev)
    
78. {
    
79.     uint32_t regval;
    
80.     uint32_t reg_base;
    
81. 
    
82.     reg_base = dev->reg_base;
    
83. 
    
84.     regval = getreg32(reg_base + I2C_CONFIG_OFFSET);
    
85.     regval |= I2C_CR_I2C_M_EN;
    
86.     putreg32(regval, reg_base + I2C_CONFIG_OFFSET);
    
87. }
    
88. 
    
89. bool bflb_i2c_isenable(struct bflb_device_s *dev)
    
90. {
    
91.     uint32_t regval;
    
92.     uint32_t reg_base;
    
93. 
    
94.     reg_base = dev->reg_base;
    
95. 
    
96.     regval = getreg32(reg_base + I2C_CONFIG_OFFSET);
    
97.     if (regval & I2C_CR_I2C_M_EN) {
    
98.         return true;
    
99.     }
    
100. 
     
101.     return false;
     
102. }
     
103. 
     
104. void bflb_i2c_disable(struct bflb_device_s *dev)
     
105. {
     
106.     uint32_t regval;
     
107.     uint32_t reg_base;
     
108. 
     
109.     reg_base = dev->reg_base;
     
110. 
     
111.     regval = getreg32(reg_base + I2C_CONFIG_OFFSET);
     
112.     regval &= ~I2C_CR_I2C_M_EN;
     
113.     putreg32(regval, reg_base + I2C_CONFIG_OFFSET);
     
114.     /* Clear I2C fifo */
     
115.     regval = getreg32(reg_base + I2C_FIFO_CONFIG_0_OFFSET);
     
116.     regval |= I2C_TX_FIFO_CLR;
     
117.     regval |= I2C_RX_FIFO_CLR;
     
118.     putreg32(regval, reg_base + I2C_FIFO_CONFIG_0_OFFSET);
     
119.     /* Clear I2C interrupt status */
     
120.     regval = getreg32(reg_base + I2C_INT_STS_OFFSET);
     
121.     regval |= I2C_CR_I2C_END_CLR;
     
122.     regval |= I2C_CR_I2C_NAK_CLR;
     
123.     regval |= I2C_CR_I2C_ARB_CLR;
     
124.     putreg32(regval, reg_base + I2C_INT_STS_OFFSET);
     
125. }
     
126. 
     
127. 
     
128. void bflb_i2c_addr_config(struct bflb_device_s *dev, uint16_t slaveaddr, uint16_t subaddr, uint8_t subaddr_size, bool is_addr_10bit)
     
129. {
     
130.     uint32_t regval;
     
131.     uint32_t reg_base;
     
132. 
     
133.     reg_base = dev->reg_base;
     
134. 
     
135.     regval = getreg32(reg_base + I2C_CONFIG_OFFSET);
     
136. 
     
137.     if (subaddr_size > 0) {
     
138.         regval |= I2C_CR_I2C_SUB_ADDR_EN;
     
139.         regval &= ~I2C_CR_I2C_SUB_ADDR_BC_MASK;
     
140.         regval |= ((subaddr_size - 1) << I2C_CR_I2C_SUB_ADDR_BC_SHIFT);
     
141.     } else {
     
142.         regval &= ~I2C_CR_I2C_SUB_ADDR_EN;
     
143.     }
     
144. 
     
145.     regval &= ~I2C_CR_I2C_SLV_ADDR_MASK;
     
146.     regval |= (slaveaddr << I2C_CR_I2C_SLV_ADDR_SHIFT);
     
147. #if !defined(BL602) && !defined(BL702)
     
148.     if (is_addr_10bit) {
     
149.         regval |= I2C_CR_I2C_10B_ADDR_EN;
     
150.     } else {
     
151.         regval &= ~I2C_CR_I2C_10B_ADDR_EN;
     
152.     }
     
153. #endif
     
154.     putreg32(subaddr, reg_base + I2C_SUB_ADDR_OFFSET);
     
155.     putreg32(regval, reg_base + I2C_CONFIG_OFFSET);
     
156. }
     
157. 
     
158. void bflb_i2c_set_datalen(struct bflb_device_s *dev, uint16_t data_len)
     
159. {
     
160.     uint32_t regval;
     
161.     uint32_t reg_base;
     
162. 
     
163.     reg_base = dev->reg_base;
     
164. 
     
165.     regval = getreg32(reg_base + I2C_CONFIG_OFFSET);
     
166.     regval &= ~I2C_CR_I2C_PKT_LEN_MASK;
     
167.     regval |= ((data_len - 1) << I2C_CR_I2C_PKT_LEN_SHIFT) & I2C_CR_I2C_PKT_LEN_MASK;
     
168.     putreg32(regval, reg_base + I2C_CONFIG_OFFSET);
     
169. }
     
170. 
     
171. 
     
172. void bflb_i2c_set_dir(struct bflb_device_s *dev, bool is_in)
     
173. {
     
174.     uint32_t regval;
     
175.     uint32_t reg_base;
     
176. 
     
177.     reg_base = dev->reg_base;
     
178. 
     
179.     regval = getreg32(reg_base + I2C_CONFIG_OFFSET);
     
180. 
     
181.     if (is_in) {
     
182.         regval |= I2C_CR_I2C_PKT_DIR;
     
183.     } else {
     
184.         regval &= ~I2C_CR_I2C_PKT_DIR;
     
185.     }
     
186.     putreg32(regval, reg_base + I2C_CONFIG_OFFSET);
     
187. }
     
188. 
     
189. 
     
190. int bflb_i2c_write_bytes(struct bflb_device_s *dev, uint8_t *data, uint32_t len, uint32_t timeout)
     
191. {
     
192.     uint32_t reg_base;
     
193.     uint32_t temp = 0;
     
194.     uint8_t *tmp_buf;
     
195.     uint64_t start_time;
     
196. 
     
197.     reg_base = dev->reg_base;
     
198.     tmp_buf = data;
     
199.     while (len >= 4) {
     
200.         for (uint8_t i = 0; i < 4; i++) {
     
201.             temp += (tmp_buf[i] << ((i % 4) * 8));
     
202.         }
     
203.         tmp_buf += 4;
     
204.         len -= 4;
     
205.         start_time = bflb_mtimer_get_time_ms();
     
206.         while ((getreg32(reg_base + I2C_FIFO_CONFIG_1_OFFSET) & I2C_TX_FIFO_CNT_MASK) == 0) {
     
207.             if ((bflb_mtimer_get_time_ms() - start_time) > timeout) {
     
208.                 return -ETIMEDOUT;
     
209.             }
     
210.         }
     
211.         putreg32(temp, reg_base + I2C_FIFO_WDATA_OFFSET);
     
212.         if (!bflb_i2c_isenable(dev)) {
     
213.             bflb_i2c_enable(dev);
     
214.         }
     
215.         temp = 0;
     
216.     }
     
217. 
     
218.     if (len > 0) {
     
219.         for (uint8_t i = 0; i < len; i++) {
     
220.             temp += (tmp_buf[i] << ((i % 4) * 8));
     
221.         }
     
222.         start_time = bflb_mtimer_get_time_ms();
     
223.         while ((getreg32(reg_base + I2C_FIFO_CONFIG_1_OFFSET) & I2C_TX_FIFO_CNT_MASK) == 0) {
     
224.             if ((bflb_mtimer_get_time_ms() - start_time) > timeout) {
     
225.                 return -ETIMEDOUT;
     
226.             }
     
227.         }
     
228.         putreg32(temp, reg_base + I2C_FIFO_WDATA_OFFSET);
     
229.         if (!bflb_i2c_isenable(dev)) {
     
230.             bflb_i2c_enable(dev);
     
231.         }
     
232.     }
     
233. 
     
234.     start_time = bflb_mtimer_get_time_ms();
     
235.     while (bflb_i2c_isbusy(dev) || !bflb_i2c_isend(dev) || bflb_i2c_isnak(dev)) {
     
236.         if ((bflb_mtimer_get_time_ms() - start_time) > timeout) {
     
237.             return -ETIMEDOUT;
     
238.         }
     
239.     }
     
240.     bflb_i2c_disable(dev);
     
241. 
     
242.     return 0;
     
243. }
     
244. 
     
245. 
     
246. int bflb_i2c_read_bytes(struct bflb_device_s *dev, uint8_t *data, uint32_t len, uint32_t timeout)
     
247. {
     
248.     uint32_t reg_base;
     
249.     uint32_t temp = 0;
     
250.     uint8_t *tmp_buf;
     
251.     uint64_t start_time;
     
252. 
     
253.     reg_base = dev->reg_base;
     
254.     tmp_buf = data;
     
255. 
     
256.     bflb_i2c_enable(dev);
     
257. 
     
258.     while (len >= 4) {
     
259.         start_time = bflb_mtimer_get_time_ms();
     
260.         while ((getreg32(reg_base + I2C_FIFO_CONFIG_1_OFFSET) & I2C_RX_FIFO_CNT_MASK) == 0) {
     
261.             if ((bflb_mtimer_get_time_ms() - start_time) > timeout) {
     
262.                 return -ETIMEDOUT;
     
263.             }
     
264.         }
     
265.         temp = getreg32(reg_base + I2C_FIFO_RDATA_OFFSET);
     
266.         PUT_UINT32_LE(tmp_buf, temp);
     
267.         tmp_buf += 4;
     
268.         len -= 4;
     
269.     }
     
270. 
     
271.     if (len > 0) {
     
272.         start_time = bflb_mtimer_get_time_ms();
     
273.         while ((getreg32(reg_base + I2C_FIFO_CONFIG_1_OFFSET) & I2C_RX_FIFO_CNT_MASK) == 0) {
     
274.             if ((bflb_mtimer_get_time_ms() - start_time) > timeout) {
     
275.                 return -ETIMEDOUT;
     
276.             }
     
277.         }
     
278.         temp = getreg32(reg_base + I2C_FIFO_RDATA_OFFSET);
     
279. 
     
280.         for (uint8_t i = 0; i < len; i++) {
     
281.             tmp_buf[i] = (temp >> (i * 8)) & 0xff;
     
282.         }
     
283.     }
     
284. 
     
285.     start_time = bflb_mtimer_get_time_ms();
     
286.     while (bflb_i2c_isbusy(dev) || !bflb_i2c_isend(dev)) {
     
287.         if ((bflb_mtimer_get_time_ms() - start_time) > timeout) {
     
288.             return -ETIMEDOUT;
     
289.         }
     
290.     }
     
291.     bflb_i2c_disable(dev);
     
292. 
     
293.     return 0;
     
294. }
     
295. 
     
296. 
     
297. 
     
298. /*
     
299. * address: the 7-bit slave address (optional); if not specified, join the bus as a controller device.
     
300. */
     
301. void begin_addr(unsigned char addr) {
     
302.     wire_timeout = 100;
     
303.     wire_timeout_flag = false;
     
304.     board_i2c_pinmux_init();
     
305.     i2c0 = bflb_device_get_by_name("i2c0");
     
306.     bflb_i2c_init(i2c0, 50000);
     
307. }
     
308. 
     
309. void begin() {
     
310.     wire_timeout = 100;
     
311.     wire_timeout_flag = false;
     
312.     board_i2c_pinmux_init();
     
313.     i2c0 = bflb_device_get_by_name("i2c0");
     
314.     bflb_i2c_init(i2c0, 50000);
     
315. }
     
316. 
     
317. void end() {
     
318.     bflb_i2c_deinit(i2c0);
     
319. }
     
320. /*
     
321. * address: the 7-bit slave address of the device to request bytes from.
     
322. *
     
323. * quantity: the number of bytes to request.
     
324. *
     
325. * stop: true or false. true will send a stop message after the request, releasing the bus.
     
326. * False will continually send a restart after the request, keeping the connection active.
     
327. */
     
328. 
     
329. int requestFrom_stop(unsigned char addr, int quantity, bool stop) {
     
330.     indexi2c = 0;
     
331.     bflb_i2c_disable(i2c0);
     
332.     bflb_i2c_enable(i2c0);
     
333.     bflb_i2c_addr_config(i2c0, addr, 0, 0, false);
     
334.     bflb_i2c_set_datalen(i2c0,quantity);
     
335.     bflb_i2c_set_dir(i2c0, 1);
     
336.     bflb_i2c_read_bytes(i2c0, rbuf,quantity,wire_timeout);
     
337.     available_count = quantity;
     
338.     if(true == stop){
     
339.         bflb_i2c_disable(i2c0);
     
340.     }
     
341.     return 0;
     
342. }
     
343. 
     
344. int requestFrom(unsigned char addr, int quantity) {
     
345.     indexi2c = 0;
     
346.     bflb_i2c_disable(i2c0);
     
347.     bflb_i2c_enable(i2c0);
     
348.     bflb_i2c_addr_config(i2c0, addr, 0, 0, false);
     
349.     bflb_i2c_set_datalen(i2c0,quantity);
     
350.     bflb_i2c_set_dir(i2c0, 1);
     
351.     bflb_i2c_read_bytes(i2c0, rbuf,quantity,wire_timeout);
     
352.     available_count = quantity;
     
353.     return 0;
     
354. }
     
355. 
     
356. /*
     
357. * address: the 7-bit address of the device to transmit to.
     
358. */
     
359. void beginTransmission(unsigned char addr) {
     
360.     //bflb_i2c_enable(i2c0);
     
361.     bflb_i2c_addr_config(i2c0, addr, 0, 0, false);
     
362.     bflb_i2c_set_dir(i2c0, 0);
     
363. }
     
364. 
     
365. /*
     
366. * stop: true or false. True will send a stop message, releasing the bus after transmission.
     
367. * False will send a restart, keeping the connection active.
     
368. *
     
369. * Returns
     
370. * 0: success.
     
371. * 1: data too long to fit in transmit buffer.
     
372. * 2: received NACK on transmit of address.
     
373. * 3: received NACK on transmit of data.
     
374. * 4: other error.
     
375. * 5: timeout
     
376. */
     
377. 
     
378. void endTransmission_stop(bool stop) {
     
379.     bflb_i2c_disable(i2c0);
     
380. }
     
381. 
     
382. void endTransmission() {
     
383.     bflb_i2c_disable(i2c0);
     
384. 
     
385. }
     
386. 
     
387. /*
     
388. * Description
     
389. * This function writes data from a peripheral device in response to a request from
     
390. * a controller device, or queues bytes for transmission from a controller to
     
391. * peripheral device (in-between calls to beginTransmission() and endTransmission()).
     
392. * Syntax
     
393. * Wire.write(value) Wire.write(string) Wire.write(data, length)
     
394. * Parameters
     
395. * value: a value to send as a single byte.
     
396. * string: a string to send as a series of bytes.
     
397. * data: an array of data to send as bytes.
     
398. * length: the number of bytes to transmit.
     
399. * Returns
     
400. * The number of bytes written (reading this number is optional).
     
401. */
     
402. int write_char(unsigned char value) {
     
403.     bflb_i2c_set_datalen(i2c0, 1);
     
404.     bflb_i2c_write_bytes(i2c0, &value, 1,wire_timeout);
     
405.   return 0;
     
406. }
     
407. int write_str(uint8_t *str) {
     
408.     bflb_i2c_set_datalen(i2c0, strlen((const char*)str));
     
409.     bflb_i2c_write_bytes(i2c0, str, strlen((const char*)str),wire_timeout);
     
410.   return 0;
     
411. }
     
412. int write_len(uint8_t *str, int len) {
     
413.     bflb_i2c_set_datalen(i2c0, len);
     
414.     int ret = bflb_i2c_write_bytes(i2c0, str, len,wire_timeout);
     
415.   return ret;
     
416. }
     
417. 
     
418. /*
     
419. * Description
     
420. * This function returns the number of bytes available for retrieval with read().
     
421. * This function should be called on a controller device after a call to
     
422. * requestFrom() or on a peripheral inside the onReceive() handler.
     
423. * available() inherits from the Stream utility class.
     
424. */
     
425. 
     
426. int available() {
     
427.     return available_count;
     
428. }
     
429. 
     
430. /*
     
431. * Description
     
432. * This function reads a byte that was transmitted from a peripheral device to
     
433. * a controller device after a call to requestFrom() or was transmitted from a
     
434. * controller device to a peripheral device. read() inherits from the Stream utility class.
     
435. * Syntax
     
436. * Wire.read()
     
437. * Parameters
     
438. * None.
     
439. * Returns
     
440. * The next byte received.
     
441. */
     
442. 
     
443. int readI2c() {
     
444.     unsigned char ret;
     
445.     if(available_count){
     
446.         available_count--;
     
447.         ret = rbuf[indexi2c];
     
448.         indexi2c++;
     
449.         return ret;
     
450.     }
     
451.     return 0;
     
452. }
     
453. 
     
454. /*
     
455. * Description
     
456. * This function modifies the clock frequency for I2C communication.
     
457. * I2C peripheral devices have no minimum working clock frequency,
     
458. * however 100KHz is usually the baseline.
     
459. * Syntax
     
460. * Wire.setClock(clockFrequency)
     
461. * Parameters
     
462. * clockFrequency: the value (in Hertz) of the desired communication clock.
     
463. * Accepted values are 100000 (standard mode) and 400000 (fast mode).
     
464. * Some processors also support 10000 (low speed mode), 1000000 (fast mode plus)
     
465. * and 3400000 (high speed mode). Please refer to the specific processor documentation
     
466. * to make sure the desired mode is supported.
     
467. * Returns
     
468. * None.
     
469. */
     
470. void setClock(int clockFrequency) {
     
471.     bflb_i2c_deinit(i2c0);
     
472.     bflb_i2c_init(i2c0, clockFrequency);
     
473. }
     
474. 
     
475. /*
     
476. * Description
     
477. * This function registers a function to be called when a peripheral device receives
     
478. * a transmission from a controller device.
     
479. * Syntax
     
480. * Wire.onReceive(handler)
     
481. * Parameters
     
482. * handler: the function to be called when the peripheral device receives data;
     
483. * this should take a single int parameter (the number of bytes read from the controller
     
484. * device) and return nothing.
     
485. * Returns
     
486. * None.
     
487. */
     
488. void onReceive(void (*callback)(int)) {
     
489.     //we not support slave mode yet
     
490. }
     
491. 
     
492. /*
     
493. * Description
     
494. * This function registers a function to be called when a controller device requests data from a peripheral device.
     
495. * Syntax
     
496. * Wire.onRequest(handler)
     
497. * Parameters
     
498. * handler: the function to be called, takes no parameters and returns nothing.
     
499. * Returns
     
500. * None.
     
501. */
     
502. void onRequest(void (*callback)()) {
     
503.     //we not support slave mode yet
     
504. }
     
505. 
     
506. /*
     
507. * Description
     
508. * Sets the timeout for Wire transmissions in master mode.
     
509. * Syntax
     
510. * Wire.setWireTimeout(timeout, reset_on_timeout)
     
511. * Wire.setWireTimeout()
     
512. * Parameters
     
513. * timeout a timeout: timeout in microseconds, if zero then timeout checking is disabled
     
514. * reset_on_timeout: if true then Wire hardware will be automatically reset on timeout
     
515. * When this function is called without parameters, a default timeout is configured that
     
516. * should be sufficient to prevent lockups in a typical single-master configuration.
     
517. * Returns
     
518. * None.
     
519. */
     
520. void setWireTimeout(int timeout, bool reset_on_timeout) {
     
521.     wire_timeout = timeout;
     
522.     wire_timeout_flag = true;
     
523. }
     
524. 
     
525. /* Description
     
526. * Clears the timeout flag.
     
527. * Timeouts might not be enabled by default. See the documentation for Wire.setWireTimeout()
     
528. * for more information on how to configure timeouts and how they work.
     
529. * Syntax
     
530. * Wire.clearTimeout()
     
531. * Parameters
     
532. * None.
     
533. * Returns
     
534. * bool: The current value of the flag
     
535. */
     
536. bool clearWireTimeoutFlag() {
     
537.     wire_timeout_flag = false;
     
538.   return true;
     
539. }
     
540. 
     
541. /*
     
542. * Description
     
543. * Checks whether a timeout has occured since the last time the flag was cleared.
     
544. * This flag is set is set whenever a timeout occurs and cleared when Wire.clearWireTimeoutFlag()
     
545. * is called, or when the timeout is changed using Wire.setWireTimeout().
     
546. * Syntax
     
547. * Wire.getWireTimeoutFlag()
     
548. * Parameters
     
549. * None.
     
550. * Returns
     
551. * bool: The current value of the flag
     
552. */
     
553. 
     
554. bool getWireTimeoutFlag() {
     
555.   return wire_timeout_flag;
     
556. }
     
557. 
     

复制代码

代码可以直接放到项目里面引用。



目前arduino 平台已经支持 I2C 的常用功能能。这里多了一种选择。

顶

顶

这种干货帖子再多点

赞

赞