21ic电子技术开发论坛 › 综合技术交流 › 电子技术交流论坛 › 八通道低侧驱动芯片SGM42406的使用分享
返回列表 发新帖我要提问

[资料干货] 八通道低侧驱动芯片SGM42406的使用分享

[复制链接]
825|2
dffzh 发表于 2025-11-12 16:30 | 显示全部楼层 |阅读模式
驱动芯片, 使用, 分享, ,
#申请原创#


@21小跑堂

SGM42406由8个相同的低侧驱动器组成，具备串行保护功能；并且集成了用于感性负载消磁的二极管，且可驱动不同类型的负载，例如有刷电机、继电器、发光二极管、单极步进电机等。
我们使用的是16引脚的SGM42406B，使用4线串行接口进行通信，如下图所示：


接下来我就先分享一下自己解读SGM42406芯片手册的获取到的一些主要信息，然后展示一下基于C语言的芯片驱动代码。
SGM42406属于低侧驱动芯片，所谓的低侧驱动，即指驱动芯片被放置在负载和地（GND）之间，而负载的另一端直接连接到电源正极，并通过控制芯片对地的通断，来控制负载的电源回路，该芯片的功能框图如下所示：

主要的引脚及功能描述和标注如下图所示：

对于芯片的使能引脚ENABLE这里需要注意一点：
对应SGM42406A型号，控制ENABLE为高电平，即为使能芯片工作；
对应SGM42406B型号，控制nENABLE为低电平，即为使能芯片工作。
SGM42406与MCU之间通过4线串行通信，通信时序可以参考SPI总线实现，可以用硬件SPI，也可以用软件SPI实现功能，即LATCH引脚对应CS信号，CLK对应CLOCK信号，DIN对应MOSI信号，DOUT对应MISO信号，通信时序如下图所示：

通过MCU将数据写入单个芯片的数据寄存器的时序如下图所示：

当然，很重要的一个信息就是芯片支持菊花链（Daisy-Chain）操作，其实菊花链连接在很多芯片上都有，不仅方便数据拓展，同时也节约MCU引脚资源。下面是该芯片的菊花链应用：

即级联的各个芯片共用LATCH，CLK，前一级芯片的DOUT引脚连接到下一级芯片的DIN引脚。
另外，芯片支持故障检测及状态输出，即当芯片出现过温、过流和短路现象时，会通过FAULT引脚输出低电平信号，MCU可以检测FAULT引脚的数据。然后如果想知道具体是哪个OUT输出造成的过流或者短路，可以通过回读故障寄存器的值来识别。
该芯片的主要寄存器主要包括三个，即：
数据寄存器：Data Register
芯片根据数据寄存器控制输出的开和关：

故障寄存器：Fault Register
用于记录芯片的过流和过载故障信息：

控制寄存器：Control Register
芯片通过设置控制寄存器来配置通电时间和输出PWM占空比，驱动电机时会用到：

然后我再分享一下SGM42406的基于C语言的驱动代码，主要包括两个文件，一个是SGM42406.c源文件，一个是SGM42406.h头文件，其中延时时间这块需要根据不同MCU平台及硬件参数自行调整，确保时序波形不失真的情况下可以满足速度要求。
其中头文件的主要代码如下所示，主要包括硬件GPIO配置（不同MCU可以自行修改），回调函数定义及对外函数接口声明等，另外可以通过使能和不使能SGM42406_B宏来配置为SGM42406A还是SGM42406B的驱动代码：
复制
  1. #ifndef __SGM42406_H__
    

  2. #define __SGM42406_H__
    


  3. 

  4. #include "at32f403a_407.h"
    

  5. #include <string.h>
    


  6. 

  7. #define  SGM42406_EN_GPIO     GPIOB
    

  8. #define  SGM42406_CLK_GPIO    GPIOB
    

  9. #define  SGM42406_LATCH_GPIO  GPIOA  
    

  10. #define  SGM42406_DIN_GPIO    GPIOB
    

  11. #define  SGM42406_FAULT_GPIO  GPIOA
    

  12. #define  SGM42406_DOUT_GPIO   GPIOB
    


  13. 


  14. 

  15. #define  SGM42406_EN_PIN          GPIO_PINS_2
    

  16. #define  SGM42406_CLK_PIN          GPIO_PINS_7
    

  17. #define  SGM42406_LATCH_GPIN  GPIO_PINS_4 // NSS pin
    

  18. #define  SGM42406_DIN_PIN          GPIO_PINS_9
    

  19. #define  SGM42406_FAULT_PIN          GPIO_PINS_8
    

  20. #define  SGM42406_DOUT_PIN          GPIO_PINS_8
    


  21. 


  22. 

  23. #define SGM42406_CLK_HIGH()  gpio_bits_write(SGM42406_CLK_GPIO, SGM42406_CLK_PIN, TRUE)
    

  24. #define SGM42406_CLK_LOW()   gpio_bits_write(SGM42406_CLK_GPIO, SGM42406_CLK_PIN, FALSE)
    


  25. 

  26. #define SGM42406_LATCH_HIGH()  gpio_bits_write(SGM42406_LATCH_GPIO, SGM42406_LATCH_GPIN, TRUE)
    

  27. #define SGM42406_LATCH_LOW()   gpio_bits_write(SGM42406_LATCH_GPIO, SGM42406_LATCH_GPIN, FALSE)
    


  28. 

  29. #define SGM42406_EN_HIGH()  gpio_bits_write(SGM42406_EN_GPIO, SGM42406_EN_PIN, TRUE)
    

  30. #define SGM42406_EN_LOW()   gpio_bits_write(SGM42406_EN_GPIO, SGM42406_EN_PIN, FALSE)
    


  31. 

  32. #define SGM42406_DIN_HIGH()  gpio_bits_write(SGM42406_DIN_GPIO, SGM42406_DIN_PIN, TRUE)
    

  33. #define SGM42406_DIN_LOW()   gpio_bits_write(SGM42406_DIN_GPIO, SGM42406_DIN_PIN, FALSE)
    


  34. 

  35. #define SGM42406_READ_DOUT()   gpio_input_data_bit_read(SGM42406_DOUT_GPIO,SGM42406_DOUT_PIN)
    


  36. 

  37. #define SGM42406_READ_FAULT()   gpio_input_data_bit_read(SGM42406_FAULT_GPIO,SGM42406_FAULT_PIN)
    


  38. 

  39. #define SGM42406_DELAY_TIME  0  //4
    


  40. 

  41. #define SGM42406_B
    


  42. 

  43. typedef enum {
    

  44.     SGM42406_L = 0,
    

  45.     SGM42406_H,
    

  46. }sgm42406_pin_sta_e;
    


  47. 

  48. typedef enum {
    

  49.     SGM42406_READ_CONTORL_REG = 0,
    

  50.     SGM42406_READ_DATA_REG,
    

  51. }sgm42406_read_reg_e;
    


  52. 

  53. typedef struct {
    

  54.     void (* set_LATCH_pin_sta)(u8 status);
    

  55.     void (* set_CLK_pin_sta)(u8 status);
    

  56.     void (* set_DIN_pin_sta)(u8 status);
    

  57. #ifdef SGM42406_A
    

  58.     void (* set_ENABLE_pin_sta)(u8 status);
    

  59. #elif defined(SGM42406_B)
    

  60.     void (* set_NENABLE_pin_sta)(u8 status);
    

  61. #endif
    


  62. 

  63.     u8 (* get_DOUT_pin_sta) (void);
    

  64.     u8 (* get_NFAULT_pin_sta) (void);
    


  65. 

  66.     void (* sgm42406_delay_us) (u32 us);
    

  67. }sgm42406_driver, *sgm42406_driver_t;
    


  68. 

  69. void sgm42406_init(void);
    

  70. void sgm42406_command_clk(u8 clk_times);
    

  71. s8 sgm42406_write_data(u8 *write_buff, u32 len);
    

  72. void sgm42406_read_fault_reg(u16 *read_buff, u8 chip_sum);
    

  73. void sgm42406_write_control_reg(u8 *write_buff, u32 len);
    

  74. void sgm42406_read_control_or_data_reg(sgm42406_read_reg_e reg, u8 *read_buff, u32 len);
    

  75. void sgm42406_fault_reg_reset(void);
    

  76. void set_clk_sta(u8 sta);
    

  77. void set_din_sta(u8 sta);
    

  78. void set_latch_sta(u8 sta);
    

  79. extern u8 get_nfault_sta(void);
    

  80. sgm42406_driver_t get_sgm42406_dev_handle(void);
    


  81. 

  82. #endif /* __SGM42406_H__ */
其中源文件的主要代码如下所示，主要包括芯片初始化接口、回调函数实现接口、写数据接口和读故障寄存器数据接口等：
复制
  1. #include "sgm42406.h"
    


  2. 

  3. sgm42406_driver sgm42406_dev0;
    


  4. 

  5. void set_clk_sta(u8 sta)
    

  6. {
    

  7.         switch(sta)
    

  8.         {
    

  9.         case 1:
    

  10.                 SGM42406_CLK_HIGH();
    

  11.                 break;
    


  12. 

  13.         case 0:
    

  14.                 SGM42406_CLK_LOW();
    

  15.                 break;
    

  16.         }
    

  17. }
    


  18. 

  19. void set_din_sta(u8 sta)
    

  20. {
    

  21.         switch(sta)
    

  22.         {
    

  23.         case 1:
    

  24.                 SGM42406_DIN_HIGH();
    

  25.                 break;
    


  26. 

  27.         case 0:
    

  28.                 SGM42406_DIN_LOW();
    

  29.                 break;
    

  30.         }
    

  31. }
    


  32. 


  33. 

  34. void set_latch_sta(u8 sta)
    

  35. {
    

  36.         switch(sta)
    

  37.         {
    

  38.         case 1:
    

  39.                 SGM42406_LATCH_HIGH();
    

  40.                 break;
    


  41. 

  42.         case 0:
    

  43.                 SGM42406_LATCH_LOW();
    

  44.                 break;
    

  45.         }
    

  46. }
    


  47. 

  48. void set_enable_sta(u8 sta)
    

  49. {
    

  50.         switch(sta)
    

  51.         {
    

  52.         case 1:
    

  53.                 SGM42406_EN_HIGH();
    

  54.                 break;
    


  55. 

  56.         case 0:
    

  57.                 SGM42406_EN_LOW();
    

  58.                 break;
    

  59.         }
    

  60. }
    


  61. 

  62. u8 get_dout_sta(void)
    

  63. {
    

  64.         return SGM42406_READ_DOUT();
    

  65. }
    


  66. 

  67. u8 get_nfault_sta(void)
    

  68. {
    

  69.         return SGM42406_READ_FAULT();
    

  70. }
    


  71. 

  72. void sgm42406_delay(u32 us)
    

  73. {
    

  74.     u32 j = 0;
    


  75. 

  76.         //while(us--)
    

  77.         {
    

  78.                 for(j = 0; j < us; j++)
    

  79.                 {
    

  80.                         __asm("nop");
    

  81.                 }
    

  82.         }
    

  83. }
    


  84. 

  85. /**
    

  86.  * [url=/u/brief]@brief[/url] 娉ㄥ唽sgm42406璁惧
    

  87.  *
    

  88.  */
    

  89. static void sgm42406_register(void)
    

  90. {
    


  91. 

  92.     sgm42406_dev0.set_CLK_pin_sta = set_clk_sta;
    

  93.     sgm42406_dev0.set_DIN_pin_sta = set_din_sta;
    

  94.     sgm42406_dev0.set_LATCH_pin_sta = set_latch_sta;
    

  95. #ifdef SGM42406_A
    

  96.     sgm42406_dev0.set_ENABLE_pin_sta = set_pin_sta;
    

  97. #elif defined(SGM42406_B)
    

  98.     sgm42406_dev0.set_NENABLE_pin_sta = set_enable_sta;
    

  99. #endif
    


  100. 

  101.     sgm42406_dev0.get_DOUT_pin_sta = get_dout_sta;
    

  102.     sgm42406_dev0.get_NFAULT_pin_sta = get_nfault_sta;
    


  103. 

  104.     sgm42406_dev0.sgm42406_delay_us = sgm42406_delay;
    

  105. }
    


  106. 

  107. /**
    

  108.  * @brief Get the sgm42406 dev handle object
    

  109.  *
    

  110.  * [url=/u/return]@return[/url] sgm42406_driver_t
    

  111.  */
    

  112. sgm42406_driver_t get_sgm42406_dev_handle(void)
    

  113. {
    

  114.     return &sgm42406_dev0;
    

  115. }
    


  116. 

  117. void sgm42406_init(void)
    

  118. {
    

  119.     sgm42406_driver_t pd;
    


  120. 

  121.     sgm42406_register();
    

  122.     pd = get_sgm42406_dev_handle();
    


  123. 

  124.     pd->set_NENABLE_pin_sta(SGM42406_L);
    

  125.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  126.     pd->set_CLK_pin_sta(SGM42406_H);
    


  127. 

  128.     pd->set_DIN_pin_sta(SGM42406_L);
    

  129. }
    


  130. 

  131. void sgm42406_command_clk(u8 clk_times)
    

  132. {
    

  133.     sgm42406_driver_t pd;
    

  134.         int i = 0;
    


  135. 

  136.     pd = get_sgm42406_dev_handle();
    


  137. 

  138.     pd->set_LATCH_pin_sta(SGM42406_L);
    

  139.     pd->set_CLK_pin_sta(SGM42406_L);
    

  140.     pd->sgm42406_delay_us(1);
    


  141. 

  142.     for(i = 0; i < clk_times; i++)
    

  143.     {
    

  144.         pd->set_CLK_pin_sta(SGM42406_H);
    

  145.         pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  146.         pd->set_CLK_pin_sta(SGM42406_L);
    

  147.         pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  148.     }
    


  149. 

  150.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  151.         pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  152. }
    


  153. 

  154. /**
    

  155.  * @brief 杈撳嚭闀垮害涓簂en鐨勬暟鎹?
    

  156.  *
    

  157.  * @param buff 瑕佽緭鍑烘暟鎹殑鍦板潃
    

  158.  * @param len 杈撳嚭鐨勫瓧鑺傛暟
    

  159.  * @return int8_t 鎴愬姛0锛屽け璐?1
    

  160.  */
    

  161. s8 sgm42406_write_data(u8 *write_buff, u32 len)
    

  162. {
    

  163.     sgm42406_driver_t pd;
    

  164.     u8 send_data = 0;
    

  165.         int i = 0;
    

  166.         int j = 0;
    


  167. 

  168.     pd = get_sgm42406_dev_handle();
    


  169. 

  170.     pd->set_LATCH_pin_sta(SGM42406_L);
    


  171. 

  172.     for(i = len; i > 0; i--) //SGM42406鑺墖涓暟
    

  173.     {
    

  174.         send_data = write_buff[i-1]; //涓轰粈涔堣鍏堝啓鏈€鍚庝竴涓猙uff鏁版嵁锛?
    

  175.         for(j = 0; j < 8; j++) //鍐?bit鏁版嵁
    

  176.         {
    

  177.             pd->set_CLK_pin_sta(SGM42406_L);
    

  178.             if((send_data << j) & 0x80)
    

  179.             {
    

  180.                 pd->set_DIN_pin_sta(SGM42406_H);
    

  181.             }
    

  182.             else
    

  183.             {
    

  184.                 pd->set_DIN_pin_sta(SGM42406_L);
    


  185. 

  186.             }
    

  187.             pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  188.             pd->set_CLK_pin_sta(SGM42406_H);
    

  189.             pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  190.         }
    

  191.         pd->set_DIN_pin_sta(SGM42406_L);
    

  192.                 pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  193.                 pd->set_CLK_pin_sta(SGM42406_H);
    

  194.     }
    


  195. 

  196.     pd->set_LATCH_pin_sta(SGM42406_H);
    


  197. 

  198.     return 0;
    

  199. }
    


  200. 

  201. /*璇诲彇 16浣嶆晠闅滃瘎瀛樺櫒 锛岃鎺ュ彛闇€瑕佷慨鏀?/
    

  202. void sgm42406_read_fault_reg(u16 *read_buff, u8 chip_sum)
    

  203. {
    

  204.     sgm42406_driver_t pd;
    

  205.     //u16 *pread = read_buff;
    

  206.     u16 read_data = 0;
    

  207.         int i = 0;
    

  208.         int j = 0;
    


  209. 

  210.     pd = get_sgm42406_dev_handle();
    


  211. 

  212. #if 0
    

  213.     pd->sgm42406_delay_us(500);
    

  214.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  215.     pd->set_CLK_pin_sta(SGM42406_H);
    

  216.     pd->sgm42406_delay_us(2);
    

  217.     pd->set_CLK_pin_sta(SGM42406_L);
    

  218.     pd->set_LATCH_pin_sta(SGM42406_L);
    

  219.     pd->sgm42406_delay_us(5);
    

  220.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  221.     pd->sgm42406_delay_us(5);
    

  222. #else
    

  223.     pd->set_CLK_pin_sta(SGM42406_H);
    

  224.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  225.     pd->sgm42406_delay_us(5);
    

  226.     pd->set_CLK_pin_sta(SGM42406_L);
    

  227.     pd->sgm42406_delay_us(5);
    

  228.     pd->set_LATCH_pin_sta(SGM42406_L);
    

  229.     pd->sgm42406_delay_us(5);
    

  230.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  231.     pd->sgm42406_delay_us(5);
    

  232.     pd->set_CLK_pin_sta(SGM42406_H);
    

  233. #endif
    


  234. 

  235.     for(i = 0; i < chip_sum; i++)
    

  236.     {
    

  237.         for(j = 0; j < 16; j++)
    

  238.         {
    

  239.             pd->set_CLK_pin_sta(SGM42406_H);
    

  240.             pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  241.             pd->set_CLK_pin_sta(SGM42406_L);
    

  242.             //pd->sgm42406_delay_us(2);
    

  243.             read_data |= (pd->get_DOUT_pin_sta() << (15-j)); //鍏堣鏈€楂樹綅
    

  244.             pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  245.         }
    

  246.         //memcpy(&pread[i], &read_data, 2);
    

  247.         read_buff[i] = read_data;
    

  248.         read_data = 0;
    

  249.     }
    

  250.     //pd->sgm42406_delay_us(500);
    

  251. }
    


  252. 

  253. void sgm42406_write_control_reg(u8 *write_buff, u32 len)
    

  254. {
    

  255.     sgm42406_driver_t pd;
    


  256. 

  257.     pd = get_sgm42406_dev_handle();
    


  258. 

  259.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  260.     pd->set_CLK_pin_sta(SGM42406_H);
    

  261.     pd->sgm42406_delay_us(2);
    

  262.     pd->set_CLK_pin_sta(SGM42406_L);
    

  263. //    pd->sgm42406_delay_us(2);
    


  264. 

  265.     sgm42406_command_clk(1);
    

  266.     sgm42406_command_clk(2);
    

  267.     sgm42406_command_clk(2);
    

  268.     sgm42406_command_clk(3);
    


  269. 

  270.     sgm42406_write_data(write_buff, len);
    

  271. }
    


  272. 

  273. void sgm42406_read_control_or_data_reg(sgm42406_read_reg_e reg, u8 *read_buff, u32 len)
    

  274. {
    

  275.     sgm42406_driver_t pd;
    

  276.     u8 *pread = read_buff;
    

  277.     u8 read_data = 0;
    

  278.         int i = 0;
    

  279.         int j = 0;
    


  280. 

  281.     pd = get_sgm42406_dev_handle();
    


  282. 

  283.     pd->set_CLK_pin_sta(SGM42406_L);
    


  284. 

  285.     switch(reg)
    

  286.     {
    

  287.         case SGM42406_READ_CONTORL_REG:
    

  288.             sgm42406_command_clk(1);
    

  289.             sgm42406_command_clk(4);
    

  290.             sgm42406_command_clk(2);
    

  291.             sgm42406_command_clk(3);
    

  292.             break;
    


  293. 

  294.         case SGM42406_READ_DATA_REG:
    

  295.             sgm42406_command_clk(1);
    

  296.             sgm42406_command_clk(4);
    

  297.             sgm42406_command_clk(4);
    

  298.             sgm42406_command_clk(3);
    

  299.             break;
    

  300.     }
    


  301. 

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

  303.     {
    

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

  305.         {
    

  306.             read_data |= (pd->get_DOUT_pin_sta() << j);
    

  307.             pd->sgm42406_delay_us(2);
    

  308.             pd->set_CLK_pin_sta(SGM42406_H);
    

  309.             pd->sgm42406_delay_us(2);
    

  310.             pd->set_CLK_pin_sta(SGM42406_L);
    

  311.             pd->sgm42406_delay_us(1);
    

  312.         }
    

  313.         memcpy(&pread[i], &read_data, 1);
    

  314.         read_data = 0;
    

  315.     }
    

  316. }
    


  317. 

  318. void sgm42406_fault_reg_reset(void)
    

  319. {
    

  320.     sgm42406_driver_t pd;
    


  321. 

  322.     pd = get_sgm42406_dev_handle();
    


  323. 

  324.     pd->set_LATCH_pin_sta(SGM42406_H);
    

  325.     pd->set_CLK_pin_sta(SGM42406_H);
    

  326.     pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    

  327.     pd->set_CLK_pin_sta(SGM42406_L);
    

  328.     pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
    


  329. 

  330.     sgm42406_command_clk(1);
    

  331.     sgm42406_command_clk(2);
    

  332.     sgm42406_command_clk(4);
    

  333.     sgm42406_command_clk(3);
    


  334. 

  335.     pd->set_CLK_pin_sta(SGM42406_H);
    

  336. }
以上的对SGM42406的解读分享，给大家提供参考。

本帖子中包含更多资源

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

×
回复

收藏 举报

相关帖子
 楼主| dffzh 发表于 2025-11-12 16:32 | 显示全部楼层
#申请原创# @21小跑堂 管理员，你好，求原创审核哦！

回复

收藏 举报

MessageRing 发表于 2025-11-18 16:16 | 显示全部楼层
代码写的很详细
回复

收藏 举报

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

本版积分规则

dffzh Image

209

主题

1804

帖子

23

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