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

本文介绍了SGM42406低侧驱动芯片的功能特点及应用。该芯片包含8个相同驱动器，支持串行保护功能和感性负载消磁，可驱动多种负载类型。文章详细解析了芯片手册信息，包括引脚功能、通信时序（类似SPI）、菊花链连接方式以及故障检测机制。同时提供了基于C语言的驱动代码实现，包含初始化、数据读写等核心功能接口。通过宏定义可适配SGM42406A/B不同型号，代码结构清晰，包含头文件和源文件实现，为开发者使

21ic电子工程师

132人浏览 · 2026-03-23 11:13:09

21ic电子工程师  ·  2026-03-23 11:13:09 发布

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__
4. #include "at32f403a_407.h"
5. #include <string.h>
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
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
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)
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)
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)
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)
35. #define SGM42406_READ_DOUT()   gpio_input_data_bit_read(SGM42406_DOUT_GPIO,SGM42406_DOUT_PIN)
37. #define SGM42406_READ_FAULT()   gpio_input_data_bit_read(SGM42406_FAULT_GPIO,SGM42406_FAULT_PIN)
39. #define SGM42406_DELAY_TIME  0  //4
41. #define SGM42406_B
43. typedef enum {
44.     SGM42406_L = 0,
45.     SGM42406_H,
46. }sgm42406_pin_sta_e;
48. typedef enum {
49.     SGM42406_READ_CONTORL_REG = 0,
50.     SGM42406_READ_DATA_REG,
51. }sgm42406_read_reg_e;
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
63.     u8 (* get_DOUT_pin_sta) (void);
64.     u8 (* get_NFAULT_pin_sta) (void);
66.     void (* sgm42406_delay_us) (u32 us);
67. }sgm42406_driver, *sgm42406_driver_t;
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);
82. #endif /* __SGM42406_H__ */

其中源文件的主要代码如下所示，主要包括芯片初始化接口、回调函数实现接口、写数据接口和读故障寄存器数据接口等：

复制

1. #include "sgm42406.h"
3. sgm42406_driver sgm42406_dev0;
5. void set_clk_sta(u8 sta)
6. {
7.         switch(sta)
8.         {
9.         case 1:
10.                 SGM42406_CLK_HIGH();
11.                 break;
13.         case 0:
14.                 SGM42406_CLK_LOW();
15.                 break;
16.         }
17. }
19. void set_din_sta(u8 sta)
20. {
21.         switch(sta)
22.         {
23.         case 1:
24.                 SGM42406_DIN_HIGH();
25.                 break;
27.         case 0:
28.                 SGM42406_DIN_LOW();
29.                 break;
30.         }
31. }
34. void set_latch_sta(u8 sta)
35. {
36.         switch(sta)
37.         {
38.         case 1:
39.                 SGM42406_LATCH_HIGH();
40.                 break;
42.         case 0:
43.                 SGM42406_LATCH_LOW();
44.                 break;
45.         }
46. }
48. void set_enable_sta(u8 sta)
49. {
50.         switch(sta)
51.         {
52.         case 1:
53.                 SGM42406_EN_HIGH();
54.                 break;
56.         case 0:
57.                 SGM42406_EN_LOW();
58.                 break;
59.         }
60. }
62. u8 get_dout_sta(void)
63. {
64.         return SGM42406_READ_DOUT();
65. }
67. u8 get_nfault_sta(void)
68. {
69.         return SGM42406_READ_FAULT();
70. }
72. void sgm42406_delay(u32 us)
73. {
74.     u32 j = 0;
76.         //while(us--)
77.         {
78.                 for(j = 0; j < us; j++)
79.                 {
80.                         __asm("nop");
81.                 }
82.         }
83. }
85. /**
86. * [url=/u/brief]@brief[/url] 娉ㄥ唽sgm42406璁惧
87. *
88. */
89. static void sgm42406_register(void)
90. {
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
101.     sgm42406_dev0.get_DOUT_pin_sta = get_dout_sta;
102.     sgm42406_dev0.get_NFAULT_pin_sta = get_nfault_sta;
104.     sgm42406_dev0.sgm42406_delay_us = sgm42406_delay;
105. }
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. }
117. void sgm42406_init(void)
118. {
119.     sgm42406_driver_t pd;
121.     sgm42406_register();
122.     pd = get_sgm42406_dev_handle();
124.     pd->set_NENABLE_pin_sta(SGM42406_L);
125.     pd->set_LATCH_pin_sta(SGM42406_H);
126.     pd->set_CLK_pin_sta(SGM42406_H);
128.     pd->set_DIN_pin_sta(SGM42406_L);
129. }
131. void sgm42406_command_clk(u8 clk_times)
132. {
133.     sgm42406_driver_t pd;
134.         int i = 0;
136.     pd = get_sgm42406_dev_handle();
138.     pd->set_LATCH_pin_sta(SGM42406_L);
139.     pd->set_CLK_pin_sta(SGM42406_L);
140.     pd->sgm42406_delay_us(1);
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.     }
150.     pd->set_LATCH_pin_sta(SGM42406_H);
151.         pd->sgm42406_delay_us(SGM42406_DELAY_TIME);
152. }
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;
168.     pd = get_sgm42406_dev_handle();
170.     pd->set_LATCH_pin_sta(SGM42406_L);
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);
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.     }
196.     pd->set_LATCH_pin_sta(SGM42406_H);
198.     return 0;
199. }
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;
210.     pd = get_sgm42406_dev_handle();
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
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. }
253. void sgm42406_write_control_reg(u8 *write_buff, u32 len)
254. {
255.     sgm42406_driver_t pd;
257.     pd = get_sgm42406_dev_handle();
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);
265.     sgm42406_command_clk(1);
266.     sgm42406_command_clk(2);
267.     sgm42406_command_clk(2);
268.     sgm42406_command_clk(3);
270.     sgm42406_write_data(write_buff, len);
271. }
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;
281.     pd = get_sgm42406_dev_handle();
283.     pd->set_CLK_pin_sta(SGM42406_L);
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;
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.     }
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. }
318. void sgm42406_fault_reg_reset(void)
319. {
320.     sgm42406_driver_t pd;
322.     pd = get_sgm42406_dev_handle();
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);
330.     sgm42406_command_clk(1);
331.     sgm42406_command_clk(2);
332.     sgm42406_command_clk(4);
333.     sgm42406_command_clk(3);
335.     pd->set_CLK_pin_sta(SGM42406_H);
336. }

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

。
---------------------
作者：dffzh
链接：https://bbs.21ic.com/icview-3495603-1-1.html?_dsign=4ba244d0
来源：21ic.com
此文章已获得原创/原创奖标签，著作权归21ic所有，任何人未经允许禁止转载。

# 单片机 # fpga开发 # 嵌入式硬件

AI智能硬件创业者社区

智能硬件社区聚焦AI智能硬件技术生态，汇聚嵌入式AI、物联网硬件开发者，打造交流分享平台，同步全国赛事资讯、开展 OPC 核心人才招募，助力技术落地与开发者成长。

加入社区

更多推荐

• · STM32CubeIDE还是Keil？2026年嵌入式开发的工具链困局
• · ESP32量产踩坑：无线认证成本比芯片贵3倍？
• · 6层PCB比4层贵50%？智能门锁主板的EMI与成本博弈

STM32CubeIDE还是Keil？2026年嵌入式开发的工具链困局

AI智能硬件创业者社区

ESP32量产踩坑：无线认证成本比芯片贵3倍？

AI智能硬件创业者社区

6层PCB比4层贵50%？智能门锁主板的EMI与成本博弈

AI智能硬件创业者社区

欢迎加入社区

取消 确定