21ic电子技术开发论坛 › 单片机与嵌入式系统 › Microchip › 【每周分享】以IS3980S为例，分享一种多板多芯片且引脚 ...
返回列表 发新帖我要提问本帖赏金: 30.00元(功能说明)

[麦麦茶水间] 【每周分享】以IS3980S为例，分享一种多板多芯片且引脚复用的驱动代码实现和应用方法

[复制链接]
10865|3
dffzh 发表于 2026-6-9 18:36 | 显示全部楼层 |阅读模式
引脚, 芯片, , 复用,
#申请原创# #技术资源#

大家直接看标题可能有点疑惑，所以我这里先解释一下，所谓的“多板多芯片且引脚复用”其实是这个意思：
就是一个产品有多个PCB板，每个板子上都有两个及以上的同样的芯片；且由于MCU引脚资源有限的问题会共用GPIO引脚以实现分时复用。
以我以前接触过的产品为例，上面有两块PCB板，一块带MCU芯片的CPU板，上面有两颗IS3980S芯片；一块带输入检测的IO板，上面也有两颗IS3980S芯片，且两块PCB板通过连接线束连接，主要是将IO板上的IS3980S芯片检测到的输入数据通过总线回传到MCU。
另外，由于MCU引脚资源有限，PCB板上的两颗IS3980S芯片的SCLK、MISO和MOSI三根信号线是共用一组GPIO引脚的，各自通过NSS片选信号进行数据读取的切换，其实就是类似于SPI的一主多从拓扑；同样的，IO板上的两颗IS3980S芯片的SCLK、MISO和MOSI三根信号线是共用另外一组GPIO引脚的，各自通过NSS片选信号进行数据读取的切换。
其实说了半天，其通过下面的框图基本上就可以知道是什么硬件拓扑了，更一目了然：
这里的IS3980S其实是一款支持8通道隔离式数字输入检测的接收器芯片，走的是四线串行总线接口，即MCU端可以用硬件SPI或者模拟SPI来实现数据读取。另外，IS3980S其实也支持菊花链连接，但是我们考虑到应用场景的抗干扰性能和数据稳定性，我们没有采用这种方式，而是采用了通过NSS片选信号进行分时复用读取数据的方式：
那对于类似我们这样的硬件设计，软件的驱动代码应该怎么实现比较好呢？首先的原则当然是驱动代码的各个函数接口尽量保证只有一个。鉴于此，我是按照下面这种方式实现的：
在原始的驱动代码的各个函数接口的形参里面加入所谓索引index的概念，比如既然有两块PCB，那就加个PCB索引pcb_index来识别是CPU板还是IO板；既然有两个芯片来复用同一组IO引脚，其实本质上是两个NSS片选信号，那就加个NSS索引nss_index来识别是哪个芯片处于激活active状态，哪个芯片处于非工作状态。

然后可以定义几个宏，比如各个板子的芯片的最大个数是2，然后需要区分是CPU板还是IO板的芯片，这个是对应pcb_index的，；识别PCB板类型后还要进一步区分是哪个芯片，这个是对应nss_index的，得到相关的宏定义如下：
复制
  1. //pcb_index
    

  2. #define IS3980S_MAX (2)
    

  3. #define CPU_IS3980S (0)
    

  4. #define KEY_IS3980S (1)
    

  5. //nss_index
    

  6. #define  IS3980S_NSS_MAX    2
    

  7. #define  CPU_IS3980S_NSS1   0
    

  8. #define  CPU_IS3980S_NSS2   1
    

  9. #define  KEY_IS3980S_NSS1   0
    

  10. #define  KEY_IS3980S_NSS2   1
然后对于SCLK、MOSI、MISO和NSS信号绑定MCU的GPIO引脚，毫无疑问是通过宏定义来完成，并以PCB板名称来作为前缀以识别，比如对于NSS引脚，可以参考如下定义：
复制
  1. #define  CPU_IS3980S_NSS1_GPIO   GPIOB
    

  2. #define  CPU_IS3980S_NSS2_GPIO   GPIOB
    

  3. #define  CPU_IS3980S_NSS1_PIN         GPIO_PINS_6
    

  4. #define  CPU_IS3980S_NSS2_PIN         GPIO_PINS_1
    


  5. 

  6. #define  KEY_IS3980S_NSS1_GPIO   GPIOA
    

  7. #define  KEY_IS3980S_NSS2_GPIO   GPIOA
    

  8. #define  KEY_IS3980S_NSS1_PIN         GPIO_PINS_9
    

  9. #define  KEY_IS3980S_NSS2_PIN         GPIO_PINS_10
这里有个建议，即使一组串行信号连接在同一个GPIO组，定义的时候也要单独分开，以增强代码扩展性和维护性。

接着就可以通过宏定义的方式并结合GPIO引脚及pcb_index和nss_index参数来实现引脚分时切换的代码，比如对于NSS、SCLK（MOSI类似）和MISO，可以实现如下：
复制
  1. #define IS3980S_NSS_HIGH(pcb_index, nss_index) \
    

  2.         do{ \
    

  3.         switch(pcb_index) \
    

  4.         { \
    

  5.             case CPU_IS3980S: \
    

  6.                                 { \
    

  7.                                     switch(nss_index) \
    

  8.                                         { \
    

  9.                         case CPU_IS3980S_NSS1: \
    

  10.                                         gpio_bits_write(CPU_IS3980S_NSS1_GPIO, CPU_IS3980S_NSS1_PIN, TRUE); \
    

  11.                                     break; \
    

  12.                                     case CPU_IS3980S_NSS2: \
    

  13.                                         gpio_bits_write(CPU_IS3980S_NSS2_GPIO, CPU_IS3980S_NSS2_PIN, TRUE); \
    

  14.                                         break; \
    

  15.                                     default:   \
    

  16.                                         break; \
    

  17.                     }\
    

  18.                     }\
    

  19.                             break; \
    

  20.                         case KEY_IS3980S: \
    

  21.                                 { \
    

  22.                                     switch(nss_index) \
    

  23.                                         { \
    

  24.                         case KEY_IS3980S_NSS1: \
    

  25.                                         gpio_bits_write(KEY_IS3980S_NSS1_GPIO, KEY_IS3980S_NSS1_PIN, TRUE); \
    

  26.                                     break; \
    

  27.                                     case KEY_IS3980S_NSS2: \
    

  28.                                         gpio_bits_write(KEY_IS3980S_NSS2_GPIO, KEY_IS3980S_NSS2_PIN, TRUE); \
    

  29.                                         break; \
    

  30.                                     default:   \
    

  31.                                         break; \
    

  32.                     }\
    

  33.                     }\
    

  34.                                 break; \
    

  35.                         default:   \
    

  36.                                 break; \
    

  37.         }\
    

  38.         }while(0);
    


  39. 

  40. #define IS3980S_SCK_HIGH(pcb_index) \
    

  41.         do{ \
    

  42.         switch(pcb_index) \
    

  43.         { \
    

  44.             case CPU_IS3980S: \
    

  45.                                 gpio_bits_write(CPU_IS3980S_SCK_GPIO, CPU_IS3980S_SCK_PIN, TRUE); \
    

  46.                             break; \
    

  47.                         case KEY_IS3980S: \
    

  48.                                 gpio_bits_write(KEY_IS3980S_SCK_GPIO, KEY_IS3980S_SCK_PIN, TRUE); \
    

  49.                                 break; \
    

  50.                         default:   \
    

  51.                                 break; \
    

  52.         }\
    

  53.         }while(0);
    


  54. 

  55. #define IS3980S_READ_MISO_CPU()  gpio_input_data_bit_read(CPU_IS3980S_MISO_GPIO, CPU_IS3980S_MISO_PIN)
    

  56. #define IS3980S_READ_MISO_KEY()  gpio_input_data_bit_read(KEY_IS3980S_MISO_GPIO, KEY_IS3980S_MISO_PIN)
然后对于这种上电时候需要通过MCU对其进行初始化配置的芯片，这种实现方法以芯片最大个数为for循环的条件即可调用一次初始化接口就能完成芯片初始化，如下所示：
复制
  1. void is3980s_all_init(void)
    

  2. {
    

  3.     uint8_t i = 0;
    

  4.         uint8_t j = 0;
    


  5. 

  6.         for(i=0; i<IS3980S_MAX; i++)
    

  7.         {
    

  8.             for(j=0; j<IS3980S_NSS_MAX; j++)
    

  9.             {
    

  10.                 is3980s_init(i, j);
    

  11.             }
    

  12.         }
    

  13. }
下面就与大家展示一下这个IS3980S芯片的多板多芯片且引脚复用的驱动代码：

头文件如下所示：
复制
  1. #ifndef __IS3980S_H__
    

  2. #define __IS3980S_H__
    


  3. 

  4. /*SPI data frame length (byte)*/
    

  5. #define IS3980S_SPI_DATA_LEN  3
    


  6. 

  7. /*hardware interface*/
    

  8. #define IS3980S_MAX (2)
    

  9. #define CPU_IS3980S (0)
    

  10. #define KEY_IS3980S (1)
    


  11. 

  12. #define  IS3980S_NSS_MAX    2
    

  13. #define  CPU_IS3980S_NSS1   0
    

  14. #define  CPU_IS3980S_NSS2   1
    

  15. #define  KEY_IS3980S_NSS1   0
    

  16. #define  KEY_IS3980S_NSS2   1
    


  17. 

  18. #define  CPU_IS3980S_GPIO            GPIOB
    

  19. #define  CPU_IS3980S_SCK_GPIO    GPIOB
    

  20. #define  CPU_IS3980S_MOSI_GPIO   GPIOB
    

  21. #define  CPU_IS3980S_MISO_GPIO   GPIOB
    

  22. #define  CPU_IS3980S_NSS1_GPIO   GPIOB
    

  23. #define  CPU_IS3980S_NSS2_GPIO   GPIOB
    


  24. 

  25. #define  CPU_IS3980S_SCK_PIN         GPIO_PINS_7
    

  26. #define  CPU_IS3980S_MOSI_PIN         GPIO_PINS_9
    

  27. #define  CPU_IS3980S_MISO_PIN         GPIO_PINS_8
    

  28. #define  CPU_IS3980S_NSS1_PIN         GPIO_PINS_6
    

  29. #define  CPU_IS3980S_NSS2_PIN         GPIO_PINS_1
    


  30. 

  31. #define  KEY_IS3980S_GPIO            GPIOB
    

  32. #define  KEY_IS3980S_SCK_GPIO    GPIOB
    

  33. #define  KEY_IS3980S_MOSI_GPIO   GPIOB
    

  34. #define  KEY_IS3980S_MISO_GPIO   GPIOB
    

  35. #define  KEY_IS3980S_NSS1_GPIO   GPIOA
    

  36. #define  KEY_IS3980S_NSS2_GPIO   GPIOA
    


  37. 

  38. #define  KEY_IS3980S_SCK_PIN         GPIO_PINS_3
    

  39. #define  KEY_IS3980S_MOSI_PIN         GPIO_PINS_5
    

  40. #define  KEY_IS3980S_MISO_PIN         GPIO_PINS_4
    

  41. #define  KEY_IS3980S_NSS1_PIN         GPIO_PINS_9
    

  42. #define  KEY_IS3980S_NSS2_PIN         GPIO_PINS_10
    


  43. 


  44. 

  45. #define IS3980S_NSS_HIGH(pcb_index, nss_index) \
    

  46.         do{ \
    

  47.         switch(pcb_index) \
    

  48.         { \
    

  49.             case CPU_IS3980S: \
    

  50.                                 { \
    

  51.                                     switch(nss_index) \
    

  52.                                         { \
    

  53.                         case CPU_IS3980S_NSS1: \
    

  54.                                         gpio_bits_write(CPU_IS3980S_NSS1_GPIO, CPU_IS3980S_NSS1_PIN, TRUE); \
    

  55.                                     break; \
    

  56.                                     case CPU_IS3980S_NSS2: \
    

  57.                                         gpio_bits_write(CPU_IS3980S_NSS2_GPIO, CPU_IS3980S_NSS2_PIN, TRUE); \
    

  58.                                         break; \
    

  59.                                     default:   \
    

  60.                                         break; \
    

  61.                     }\
    

  62.                     }\
    

  63.                             break; \
    

  64.                         case KEY_IS3980S: \
    

  65.                                 { \
    

  66.                                     switch(nss_index) \
    

  67.                                         { \
    

  68.                         case KEY_IS3980S_NSS1: \
    

  69.                                         gpio_bits_write(KEY_IS3980S_NSS1_GPIO, KEY_IS3980S_NSS1_PIN, TRUE); \
    

  70.                                     break; \
    

  71.                                     case KEY_IS3980S_NSS2: \
    

  72.                                         gpio_bits_write(KEY_IS3980S_NSS2_GPIO, KEY_IS3980S_NSS2_PIN, TRUE); \
    

  73.                                         break; \
    

  74.                                     default:   \
    

  75.                                         break; \
    

  76.                     }\
    

  77.                     }\
    

  78.                                 break; \
    

  79.                         default:   \
    

  80.                                 break; \
    

  81.         }\
    

  82.         }while(0);
    


  83. 


  84. 

  85. #define IS3980S_NSS_LOW(pcb_index, nss_index) \
    

  86.         do{ \
    

  87.         switch(pcb_index) \
    

  88.         { \
    

  89.             case CPU_IS3980S: \
    

  90.                                 { \
    

  91.                                     switch(nss_index) \
    

  92.                                         { \
    

  93.                         case CPU_IS3980S_NSS1: \
    

  94.                                             gpio_bits_write(CPU_IS3980S_NSS1_GPIO, CPU_IS3980S_NSS1_PIN, FALSE); \
    

  95.                                         break; \
    

  96.                                     case CPU_IS3980S_NSS2: \
    

  97.                                             gpio_bits_write(CPU_IS3980S_NSS2_GPIO, CPU_IS3980S_NSS2_PIN, FALSE); \
    

  98.                                             break; \
    

  99.                                     default:   \
    

  100.                                             break; \
    

  101.                     }\
    

  102.                     }\
    

  103.                             break; \
    

  104.                         case KEY_IS3980S: \
    

  105.                                 { \
    

  106.                                     switch(nss_index) \
    

  107.                                         { \
    

  108.                         case KEY_IS3980S_NSS1: \
    

  109.                                             gpio_bits_write(KEY_IS3980S_NSS1_GPIO, KEY_IS3980S_NSS1_PIN, FALSE); \
    

  110.                                         break; \
    

  111.                                     case KEY_IS3980S_NSS2: \
    

  112.                                             gpio_bits_write(KEY_IS3980S_NSS2_GPIO, KEY_IS3980S_NSS2_PIN, FALSE); \
    

  113.                                             break; \
    

  114.                                     default:   \
    

  115.                                             break; \
    

  116.                     }\
    

  117.                     }\
    

  118.                                 break; \
    

  119.                         default:   \
    

  120.                                 break; \
    

  121.         }\
    

  122.         }while(0);
    


  123. 

  124. #define IS3980S_SCK_HIGH(pcb_index) \
    

  125.         do{ \
    

  126.         switch(pcb_index) \
    

  127.         { \
    

  128.             case CPU_IS3980S: \
    

  129.                                 gpio_bits_write(CPU_IS3980S_SCK_GPIO, CPU_IS3980S_SCK_PIN, TRUE); \
    

  130.                             break; \
    

  131.                         case KEY_IS3980S: \
    

  132.                                 gpio_bits_write(KEY_IS3980S_SCK_GPIO, KEY_IS3980S_SCK_PIN, TRUE); \
    

  133.                                 break; \
    

  134.                         default:   \
    

  135.                                 break; \
    

  136.         }\
    

  137.         }while(0);
    


  138. 

  139. #define IS3980S_SCK_LOW(pcb_index) \
    

  140.         do{ \
    

  141.         switch(pcb_index) \
    

  142.         { \
    

  143.             case CPU_IS3980S: \
    

  144.                                 gpio_bits_write(CPU_IS3980S_SCK_GPIO, CPU_IS3980S_SCK_PIN, FALSE); \
    

  145.                             break; \
    

  146.                         case KEY_IS3980S: \
    

  147.                                 gpio_bits_write(KEY_IS3980S_SCK_GPIO, KEY_IS3980S_SCK_PIN, FALSE); \
    

  148.                                 break; \
    

  149.                         default:   \
    

  150.                                 break; \
    

  151.         }\
    

  152.         }while(0);
    


  153. 


  154. 

  155. #define IS3980S_MOSI_HIGH(pcb_index) \
    

  156.         do{ \
    

  157.         switch(pcb_index) \
    

  158.         { \
    

  159.             case CPU_IS3980S: \
    

  160.                                 gpio_bits_write(CPU_IS3980S_MOSI_GPIO, CPU_IS3980S_MOSI_PIN, TRUE); \
    

  161.                             break; \
    

  162.                         case KEY_IS3980S: \
    

  163.                                 gpio_bits_write(KEY_IS3980S_MOSI_GPIO, KEY_IS3980S_MOSI_PIN, TRUE); \
    

  164.                                 break; \
    

  165.                         default:   \
    

  166.                                 break; \
    

  167.         }\
    

  168.         }while(0);
    


  169. 

  170. #define IS3980S_MOSI_LOW(pcb_index) \
    

  171.         do{ \
    

  172.         switch(pcb_index) \
    

  173.         { \
    

  174.             case CPU_IS3980S: \
    

  175.                                 gpio_bits_write(CPU_IS3980S_MOSI_GPIO, CPU_IS3980S_MOSI_PIN, FALSE); \
    

  176.                             break; \
    

  177.                         case KEY_IS3980S: \
    

  178.                                 gpio_bits_write(KEY_IS3980S_MOSI_GPIO, KEY_IS3980S_MOSI_PIN, FALSE); \
    

  179.                                 break; \
    

  180.                         default:   \
    

  181.                                 break; \
    

  182.         }\
    

  183.         }while(0);
    


  184. 

  185. #define IS3980S_READ_MISO_CPU()  gpio_input_data_bit_read(CPU_IS3980S_MISO_GPIO, CPU_IS3980S_MISO_PIN)
    

  186. #define IS3980S_READ_MISO_KEY()  gpio_input_data_bit_read(KEY_IS3980S_MISO_GPIO, KEY_IS3980S_MISO_PIN)
    


  187. 

  188. //delay time
    

  189. #define IS3980S_DELAY_TIME  25 
    

  190. #define IS3980S_SYNC_TIME   10
    


  191. 

  192. /*SPI data*/
    

  193. typedef struct
    

  194. {
    

  195.     u8 ctrl_byte; //control byte
    

  196.     u8 addr_byte; //address byte
    

  197.     u8 data_byte; //data byte
    

  198. }is3980s_spi_data_t;
    

  199. extern is3980s_spi_data_t is3980s_data;
    


  200. 

  201. /*chip register address*/
    

  202. typedef enum {
    

  203.     IS3980S_CHAN_STATUS_REG = 0x00,  //status register,8bit,only read,show input status of 8 channels
    

  204.         IS3980S_BDNC_MODE0_REG  = 0x01,  //filter mode set register, A1~A4 channels config
    

  205.         IS3980S_BDNC_MODE1_REG  = 0x02,  //A5~A8 channels config
    

  206.         IS3980S_BDNC_DLY0_REG   = 0x03,  //filter time set register, A1~A4 channels config
    

  207.         IS3980S_BDNC_DLY1_REG   = 0x04,  //A5~A8 channels config
    

  208. }is3980s_reg_addr_e;
    


  209. 

  210. /*read and write cmd config*/
    

  211. typedef enum {
    

  212.         IS3980S_RW_WRITE = 0,
    

  213.         IS3980S_RW_READ  = 1,
    

  214. }is3980s_rw_command_e;
    


  215. 

  216. /*define device id to write low 4 bits of control byte, CID[3:0]*/
    

  217. typedef enum {
    

  218.         IS3980S_CID_0 = 0,  //connect spi master when config which CID
    

  219.         IS3980S_CID_1,
    

  220.         IS3980S_CID_2,
    

  221.         IS3980S_CID_3,
    

  222.         IS3980S_CID_4,
    

  223. }is3980s_cid_e;
    


  224. 

  225. /*define boradcast cmd to write bit7 of control byte*/
    

  226. typedef enum {
    

  227.         IS3980S_BRCT_DISABLE = 0, //only operate CID device of addressing
    

  228.         IS3980S_BRCT_ENABLE  = 1, //operate all CID devices of daisy chain
    

  229. }is3980s_op_brct_e;
    


  230. 

  231. /*define common rw data of control byte*/
    

  232. typedef enum {
    

  233.         CTRL_DATA_BRCT_W = 0x80, //broadcast+write: 1000 0000
    

  234.         CTRL_DATA_W_CID_0 = 0x00, //unicast+write CID_0: 0000 0000
    

  235.         CTRL_DATA_W_CID_1 = 0x08, //unicast+write CID_1: 0000 1000
    

  236.         CTRL_DATA_R_CID_0 = 0x40, //unicast+read CID_0: 0100 0000
    

  237.         CTRL_DATA_R_CID_1 = 0x48, //unicast+read CID_1: 0100 1000
    

  238.         CTRL_DATA_R_CID_2 = 0x44, //unicast+read CID_2: 0100 0100
    

  239.         CTRL_DATA_R_CID_3 = 0x4C, //unicast+read CID_3: 0100 1100
    

  240.         CTRL_DATA_R_CID_4 = 0x42, //unicast+read CID_0: 0100 0010
    

  241. }is3980s_op_ctrl_data_e;
    


  242. 

  243. extern void is3980s_all_init(void);
    

  244. extern void is3980s_init(uint8_t pcb_index, uint8_t nss_index);
    

  245. extern void is3980s_write(uint8_t pcb_index, uint8_t nss_index, uint8_t *write_buff, uint8_t len);
    

  246. extern void is3980s_read(uint8_t pcb_index, uint8_t nss_index, uint8_t *read_buff, uint8_t len);
    

  247. extern void is3980s_write_byte(uint8_t pcb_index, uint8_t nss_index, uint8_t write_byte);
    

  248. extern uint8_t is3980s_read_byte(uint8_t pcb_index, uint8_t nss_index);
    

  249. extern void is3980s_sync(uint8_t pcb_index, uint8_t nss_index);
    

  250. extern void is3980s_set_filter(uint8_t pcb_index, uint8_t nss_index, uint8_t filter_mode, uint8_t filter_time);
    


  251. 

  252. #endif /* __IS3980S_H__ */
源文件如下所示：
复制
  1. #include "is3980s.h"
    


  2. 

  3. is3980s_spi_data_t is3980s_data;
    

  4. uint8_t test_data[2];
    


  5. 

  6. /* init all IS3980S CHIP */
    

  7. void is3980s_all_init(void)
    

  8. {
    

  9.     uint8_t i = 0;
    

  10.         uint8_t j = 0;
    


  11. 

  12.         for(i=0; i<IS3980S_MAX; i++)
    

  13.         {
    

  14.             for(j=0; j<IS3980S_NSS_MAX; j++)
    

  15.             {
    

  16.                 is3980s_init(i, j);
    

  17.             }
    

  18.         }
    

  19. }
    


  20. 


  21. 

  22. /* config IS3980S */
    

  23. void is3980s_init(uint8_t pcb_index, uint8_t nss_index)
    

  24. {
    

  25.         uint8_t spi_frame[IS3980S_SPI_DATA_LEN]; //control+address+data
    


  26. 

  27.         /*pin config*/
    

  28.         IS3980S_NSS_HIGH(pcb_index, nss_index);
    

  29.         IS3980S_SCK_HIGH(pcb_index);
    

  30.         IS3980S_MOSI_LOW(pcb_index);
    


  31. 

  32.         /*config when power on to make sure chip can work stable*/
    

  33.         //write data 0x55 to address 0x0A
    

  34.         spi_frame[0] = CTRL_DATA_BRCT_W;
    

  35.         spi_frame[1] = 0x0A;
    

  36.         spi_frame[2] = 0x55;
    

  37.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    

  38.         //write data 0x44 to address 0x09
    

  39.         spi_frame[1] = 0x09;
    

  40.         spi_frame[2] = 0x44;
    

  41.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    

  42.         //write data 0x00 to address 0x0A
    

  43.         spi_frame[1] = 0x0A;
    

  44.         spi_frame[2] = 0x00;
    

  45.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    

  46. }
    


  47. 

  48. /*inaccuracy delay*/
    

  49. static void is3980s_delay(uint32_t count)
    

  50. {
    

  51.         uint32_t i;
    

  52.         
    

  53.         for(i = 0; i < count; i++)
    

  54.         {
    

  55.                 __asm("nop");
    

  56.         }
    

  57. }
    


  58. 

  59. /*get miso pin data*/
    

  60. static uint8_t is3980s_get_miso(uint8_t pcb_index)
    

  61. {
    

  62.     uint8_t value = 0;
    

  63.   
    

  64.     if(CPU_IS3980S == pcb_index)
    

  65.     {
    

  66.         value = IS3980S_READ_MISO_CPU();
    

  67.     }
    

  68.         else if(KEY_IS3980S == pcb_index)
    

  69.         {
    

  70.             value = IS3980S_READ_MISO_KEY();
    

  71.         }
    

  72.         return value;
    

  73. }
    


  74. 


  75. 

  76. /*write datas*/
    

  77. void is3980s_write(uint8_t pcb_index, uint8_t nss_index, uint8_t *write_buff, uint8_t len)
    

  78. {
    

  79.         uint8_t i;
    

  80.         
    

  81.         for(i=0; i < len; i++)
    

  82.         {
    

  83.                 is3980s_write_byte(pcb_index, nss_index, write_buff[i]);
    

  84.         }
    

  85. }
    


  86. 

  87. /*read datas*/
    

  88. void is3980s_read(uint8_t pcb_index, uint8_t nss_index, uint8_t *read_buff, uint8_t len)
    

  89. {
    

  90.         uint8_t i;
    

  91.         
    

  92.         for(i=0; i < len; i++)
    

  93.         {
    

  94.                 read_buff[i] = is3980s_read_byte(pcb_index, nss_index);
    

  95.         }
    

  96. }
    


  97. 

  98. /*write byte data*/
    

  99. void is3980s_write_byte(uint8_t pcb_index, uint8_t nss_index, uint8_t write_byte)
    

  100. {
    

  101.         uint8_t i;
    

  102.         
    

  103.         IS3980S_NSS_LOW(pcb_index, nss_index);
    

  104.         is3980s_delay(IS3980S_DELAY_TIME);
    

  105.         for(i = 0; i<8; i++)
    

  106.         {
    

  107.                 IS3980S_SCK_LOW(pcb_index);
    

  108.                 if(write_byte & 0x80)
    

  109.                 {
    

  110.                         IS3980S_MOSI_HIGH(pcb_index);
    

  111.                 }
    

  112.                 else
    

  113.                 {
    

  114.                         IS3980S_MOSI_LOW(pcb_index);
    

  115.                 }
    

  116.                 write_byte <<= 1;
    

  117.                 is3980s_delay(IS3980S_DELAY_TIME);
    

  118.                 IS3980S_SCK_HIGH(pcb_index);
    

  119.                 is3980s_delay(IS3980S_DELAY_TIME);
    

  120.         }
    

  121.         is3980s_delay(IS3980S_DELAY_TIME);
    

  122.         IS3980S_NSS_HIGH(pcb_index, nss_index);
    

  123.         is3980s_delay(IS3980S_DELAY_TIME);
    

  124. }
    


  125. 

  126. /*read byte data*/
    

  127. uint8_t is3980s_read_byte(uint8_t pcb_index, uint8_t nss_index)
    

  128. {
    

  129.         uint8_t read_byte = 0;
    

  130.         uint8_t i;
    


  131. 

  132.         IS3980S_NSS_LOW(pcb_index, nss_index);
    

  133.         is3980s_delay(3);
    

  134.         for(i = 0; i<8; i++)
    

  135.         {
    

  136.                 IS3980S_SCK_LOW(pcb_index);
    

  137.                 is3980s_delay(IS3980S_DELAY_TIME);
    

  138.                 IS3980S_SCK_HIGH(pcb_index);
    

  139.                 read_byte = read_byte << 1;
    

  140.                 //is3980s_delay(5);
    

  141.                 if(is3980s_get_miso(pcb_index))
    

  142.                 {
    

  143.                         read_byte |= 0x01;
    

  144.                 }
    

  145.                 else
    

  146.                 {
    

  147.                         read_byte &= ~0x01;
    

  148.                 }
    

  149.                 //IS3980S_SCK_HIGH(pcb_index);
    

  150.                 is3980s_delay(IS3980S_DELAY_TIME);
    

  151.         }
    

  152.         is3980s_delay(IS3980S_DELAY_TIME);
    

  153.         IS3980S_NSS_HIGH(pcb_index, nss_index);
    

  154.         is3980s_delay(3);
    

  155.         return read_byte;
    

  156. }
    


  157. 

  158. /*send sync signal*/
    

  159. void is3980s_sync(uint8_t pcb_index, uint8_t nss_index)
    

  160. {
    

  161.         IS3980S_NSS_HIGH(pcb_index, nss_index);
    


  162. 

  163.         IS3980S_SCK_LOW(pcb_index);
    

  164.         is3980s_delay(IS3980S_SYNC_TIME);
    

  165.         IS3980S_SCK_HIGH(pcb_index);
    

  166.         is3980s_delay(IS3980S_SYNC_TIME);
    

  167.         IS3980S_SCK_HIGH(pcb_index);
    

  168.         is3980s_delay(IS3980S_SYNC_TIME);
    

  169. }
    


  170. 

  171. /*set filter time*/
    

  172. void is3980s_set_filter(uint8_t pcb_index, uint8_t nss_index, uint8_t filter_mode, uint8_t filter_time)
    

  173. {
    

  174.         uint8_t spi_frame[IS3980S_SPI_DATA_LEN];
    


  175. 

  176.         is3980s_sync(pcb_index, nss_index);
    


  177. 

  178.         /*config filter mode for A1~A4 channel*/
    

  179.         spi_frame[0] = CTRL_DATA_BRCT_W;
    

  180.         spi_frame[1] = IS3980S_BDNC_MODE0_REG;
    

  181.         spi_frame[2] = filter_mode;
    

  182.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    


  183. 

  184.         /*config filter mode for A5~A8 channel*/
    

  185.         spi_frame[1] = IS3980S_BDNC_MODE1_REG;
    

  186.         spi_frame[2] = filter_mode;
    

  187.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    


  188. 

  189.         /*config filter time for A5~A8 channel*/
    

  190.         spi_frame[1] = IS3980S_BDNC_DLY0_REG;
    

  191.         spi_frame[2] = filter_time;
    

  192.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    


  193. 

  194.         /*config filter time for A5~A8 channel*/
    

  195.         spi_frame[1] = IS3980S_BDNC_DLY1_REG;
    

  196.         spi_frame[2] = filter_time;
    

  197.         is3980s_write(pcb_index, nss_index, spi_frame, IS3980S_SPI_DATA_LEN);
    


  198. 

  199.         //readback test
    

  200. //        is3980s_write_byte(pcb_index, nss_index, CTRL_DATA_R_CID_0);
    

  201. //        is3980s_write_byte(pcb_index, nss_index, IS3980S_BDNC_DLY0_REG);
    

  202. //        test_data[0] = is3980s_read_byte();
    

  203. //        is3980s_write_byte(pcb_index, nss_index, CTRL_DATA_R_CID_1);
    

  204. //        is3980s_write_byte(pcb_index, nss_index, IS3980S_BDNC_DLY1_REG);
    

  205. //        test_data[1] = is3980s_read_byte(pcb_index, nss_index);
    

  206. }
显而易见，基本上每个函数接口都带有两个形参：
uint8_t pcb_index

uint8_t nss_index
最原始的驱动代码其实是下面这个造型：
当我们在实际应用的时候，首先就要分时复用，通过NSS信号来激活其中一个芯片，类似下面的代码，拉高NSS信号即deactive芯片：
复制
  1. static void cpu_spi_active_config(uint8_t chip_index)
    

  2. {
    

  3.     switch(chip_index)
    

  4.     {
    

  5.         case CPU_SPI_IS3980S_ENCODER:
    

  6.                 {
    

  7.                         IS3980S_NSS_HIGH(CPU_IS3980S, CPU_IS3980S_NSS2);
    

  8.                         break;
    

  9.                 }
    

  10.                 case CPU_SPI_IS3980S_DI:
    

  11.                 {
    

  12.                         IS3980S_NSS_HIGH(CPU_IS3980S, CPU_IS3980S_NSS1);
    

  13.                         break;
    

  14.                 }
    

  15.                 default:
    

  16.                 {
    

  17.                         IS3980S_NSS_HIGH(CPU_IS3980S, CPU_IS3980S_NSS1);
    

  18.                         IS3980S_NSS_HIGH(CPU_IS3980S, CPU_IS3980S_NSS2);
    

  19.                         break;
    

  20.                 }
    

  21.     }
    

  22. }
    


  23. 

  24. static void key_spi_active_config(uint8_t chip_index)
    

  25. {
    

  26.     switch(chip_index)
    

  27.     {
    

  28.         case KEY_SPI_IS3980S_CN631:
    

  29.                 {
    

  30.                         IS3980S_NSS_HIGH(KEY_IS3980S, KEY_IS3980S_NSS2);
    

  31.                         break;
    

  32.                 }
    

  33.                 case KEY_SPI_IS3980S_CN748:
    

  34.                 {
    

  35.                         IS3980S_NSS_HIGH(KEY_IS3980S, KEY_IS3980S_NSS1);
    

  36.                         break;
    

  37.                 }
    

  38.                 default:
    

  39.                 {
    

  40.                         IS3980S_NSS_HIGH(KEY_IS3980S, KEY_IS3980S_NSS1);
    

  41.                         IS3980S_NSS_HIGH(KEY_IS3980S, KEY_IS3980S_NSS2);
    

  42.                         break;
    

  43.                 }
    

  44.     }
    

  45. }
然后在对应位置使用下面的接口即可进行数据读取：
复制
  1. di_data0 = di_thread(CPU_IS3980S, CPU_IS3980S_NSS1);
    

  2. di_data1 = di_thread(CPU_IS3980S, CPU_IS3980S_NSS2);        
    

  3. di_data2 = di_thread(KEY_IS3980S, KEY_IS3980S_NSS1);        
    

  4. di_data3 = di_thread(KEY_IS3980S, KEY_IS3980S_NSS2);       
其中di_thread这个线程函数里面就是读写输入数据的代码，其形参也是uint8_t pcb_index和uint8_t nss_index：
复制
  1. uint8_t di_thread(uint8_t pcb_index, uint8_t nss_index)
    

  2. {
    

  3.         uint8_t di_write_data = 0;
    

  4.         uint8_t di_read_data = 0;
    

  5.         //sync
    

  6.         is3980s_sync(pcb_index, nss_index);
    

  7.         di_write_data = di_set_cid_data(0);
    

  8.         is3980s_write(pcb_index, nss_index, &di_write_data, 1);
    

  9.         di_write_data = IS3980S_CHAN_STATUS_REG;
    

  10.         is3980s_write(pcb_index, nss_index, &di_write_data, 1);
    

  11.         is3980s_read(pcb_index, nss_index, &di_read_data, 1);
    

  12.         return di_read_data;
    

  13. }
对于更多类似的硬件设计，通过这种方法实现的驱动代码里面的各个函数接口，基本上每个都会携带pcb_index和nss_index参数，然后函数里面的代码都会涉及，看着是有点复杂，但是扩展性和维护性相对来说还是不错的。当然，你还可以视具体情况增加更多的index来识别。

话说回来，这种设计肯定不是最好最优的，毕竟仁者见仁，智者见智，比如也可以通过定义结构体+表驱动法来实现；这里咱就权当是抛砖引玉，有更好的想法和设计的大神请不吝赐教~~

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

打赏榜单

21小跑堂 打赏了 30.00 元 2026-07-13
理由：恭喜通过原创审核！期待您更多的原创作品~

评论

21小跑堂
该文章从软件架构设计的层面切入。作者通过实际案例展示了如何利用C语言的宏定义和参数传递机制，解决嵌入式开发中常见的硬件资源冲突与管理...  发表于 2026-7-13 16:11

相关帖子
gaoyang9992006 发表于 2026-6-10 09:29 | 显示全部楼层
代码的TAB设置一下，用空格代替，不然贴出来就这样了。
回复

收藏 举报

 楼主| dffzh 发表于 2026-6-10 10:28 | 显示全部楼层
gaoyang9992006 发表于 2026-6-10 09:29
代码的TAB设置一下，用空格代替，不然贴出来就这样了。

编码一般都是用空格缩进的，估计是代码编辑器的原因
回复

收藏 举报

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

本版积分规则

dffzh Image

544

主题

3898

帖子

26

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