SM74HC595D电路级联教程

逃离我推掉我的手 2023-01-07 07:29 141阅读 0赞

**SM74HC595D****电路级联教程**

**1****简述**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70][]

SM74HC595D 是一种具有8 位锁存、8 位串行输入、 8 位串/并行输出、 串—并移位寄存器和三态输出功能的通用LED 驱动芯片。具有8 位移位寄存器和一个存储器，三态输出功能。 该设备具有串行输入（SER）和串行输出（Q7S）来级联和异步复位输入SCLR的功能。

移位寄存器和存储寄存器时钟都是分开的。

在移位寄存器时钟（SCK）的上升沿时，SER上的数据会被移入移位寄存器，在存储寄存器时钟（RCK）上升沿时，移位寄存器里的数据传输到存储寄存器，当输出使能G为低时，存储寄存器里的数据就会并行输出。

当SCLR为低电平时复位移位寄存器，即将移位寄存器数据清零。

当OE为高电平时输出为高阻态。

**2** **引脚功能**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 1][]

**3** **真值表**

再来看看该芯片的的真值表图。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 2][]

从真值表中可以看出其逻辑关系，主要使用红框部分。

**4** **逻辑关系**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 3][]

从功能框图中可以看出，引脚10、11、14都是作用在移位寄存器的，被传输的数据先进入移位寄存器，再通过SCK将移位寄存器的数据存入存储寄存器，最后通过输出使能端\\G使能数据并行输出，引脚9 Q7S用于级联。

我们知道74HC595是将数据串转并的，也就是数据（8bit）串行输入，并行输出。串行并行这些概念就不多说了，不清楚的自行查资料。

使用步骤：

1、先把要传输的数据（8bit）从引脚14 SER输入到74HC595

2、将从SER上的数据串行移入移位寄存器，需要时钟驱动，即引脚11（SCK）每产生一个上升沿，SER上的数据往移位寄存器送入一位，先送低位，后送高位，经过8个上升沿后，8bit全部送入移位寄存器了。

3、将移位寄存器里的数据送入存储寄存器，引脚12（STCP）产生一个上升沿后，该操作就完成了。

4、引脚13（G）为低电平，则步骤3送入存储寄存器的8bit数据（一个字节）就在Q7-Q0并行输出，并输出的数据会被所存起来。

注意：数据并行输出后，只要没有数据更新进来，原输出的数据保持不变，就是所谓的锁存（数据被锁存住）。在完成步骤123后，只要步骤4还没使能，输出都是保持不变的（这里是有误的，输出不是保持不变，不使能，输出是呈高阻态），当OE一使能，新的数据就输出，覆盖旧输出。

**5****单片595串转并输出过程**

最后以图片的形式简单描述将0x11并行输出的过程：

0x11转为二进制是 0001 0001，串转并过程如图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 4][]

**5****单片595电路**

74HC595的工作原理我们清楚知道要驱动595主要是控制5个引脚：引脚14（DS）、引脚11（SHCP）、引脚12（STCP）和引脚13（OE）。

以74HC595驱动8个LED灯为例设计一个简单电路：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 5][]

电源和地引脚就不用多说了，上5V，电源引脚加了个0.1uF的去耦电容。

这个电路中，我把引脚13直接接地，芯片是一直处于输出使能的，**引脚10接了个上拉电阻到5V，也就是主复位不使能，不使用复位功能。**

引脚14、引脚11和引脚12可以连接到单片机的IO引脚，通过单片机编程来驱动74HC595，Q7-Q0连接需控制的负载，这里就是8个LED了。

**6 595****级联电路**

单个74HC595的电路就这样子了，是不是很简单？接下来说下595如何级联使用，我在datasheet中好像没看到最多级联个数，据说可以无限级联，我自己最多级联了4个。

74HC595的级联电路很简单，只需把前一个595的引脚9（Q7S）连接到下一个595的引脚14（DS）即可，如图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 6][]

74HC595的级联电路设计是不是很简单？为什么这样子就可以实现级联呢？

在前一篇文章也提到74HC595是串行输入，串行/并行输出的，级联就用到这个串行输出了，也就是引脚9，通过引脚9把数据传到下一级595的引脚14（DS），根据图3来说下级联数据传送的原理。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 7][]

假如往第一级的595连续发三个字节数据：ABCD EFGH、IJKLP MNOP、QRST UVWX，第一个字节ABCD EFGH先进入第一级595移位寄存器；

当第二个数据IJKLP MNOP到来时，也往第一级595移位寄存器移，而第一个字节就会被挤出到第二个移位寄存器；

当第三个数据QRST UVWX到来时，也往第一级移位寄存器移，第二个字节就被挤出到第二级移位寄存器移，而一个字节就被挤出到第三级移位寄存器移；

由于OE引脚一直低电平，所以当STCP产生上升沿后，这三个字节就并行输出了。

注意：由于级联数据是被挤出到下一级的，**所以先发送的数据最后是到最后一级595的。**

好了，74HC595的电路设计就说到这里，下一篇595文章会讲一下stm32分别用IO模拟时序和SPI总线两种方式控制595控制595实现流水灯的功能。

**7 74HC595****级联电路编程（模拟IO口控制）**

前面两篇文章已详细分析过74HC595的工作原理，接下来讲下用stm32去驱动两片74HC595控制16个LED实现流水灯效果。

这篇的代码是用IO模拟74HC595时序驱动的，下一篇文章，我们介绍下如何用SPI来驱动。直接贴上代码分析，代码很简单，每个语句的注释都说得很清楚了。。。。。。

开发平台：MDK5.14

MCU：STM32F103ZET6

74HC595头文件

\#ifndef \_\_595\_H

\#define \_\_595\_H

\#include "stm32f10x.h"

\#define SHCP\_GPIO\_PORT      GPIOB

\#define SHCP\_GPIO\_CLK       RCC\_APB2Periph\_GPIOB

\#define SHCP\_GPIO\_PIN       GPIO\_Pin\_13

\#define STCP\_GPIO\_PORT      GPIOB

\#define STCP\_GPIO\_CLK       RCC\_APB2Periph\_GPIOB

\#define STCP\_GPIO\_PIN       GPIO\_Pin\_12

\#define DS\_GPIO\_PORT        GPIOB

\#define DS\_GPIO\_CLK         RCC\_APB2Periph\_GPIOB

\#define DS\_GPIO\_PIN     GPIO\_Pin\_15

\#define HC595\_SHCP\_Low()      GPIO\_ResetBits( SHCP\_GPIO\_PORT, SHCP\_GPIO\_PIN )

\#define HC595\_SHCP\_High()     GPIO\_SetBits( SHCP\_GPIO\_PORT, SHCP\_GPIO\_PIN )

\#define HC595\_STCP\_Low()      GPIO\_ResetBits( STCP\_GPIO\_PORT, STCP\_GPIO\_PIN )

\#define HC595\_STCP\_High()     GPIO\_SetBits( STCP\_GPIO\_PORT, STCP\_GPIO\_PIN )

\#define HC595\_Data\_Low()      GPIO\_ResetBits( DS\_GPIO\_PORT, DS\_GPIO\_PIN )

\#define HC595\_Data\_High()     GPIO\_SetBits( DS\_GPIO\_PORT, DS\_GPIO\_PIN )

void HC595\_GPIO\_Config(void);

void HC595\_Send\_Byte(u8 byte);

void HC595\_CS(void);

void HC595\_Send\_Multi\_Byte(u8 \*data, u16 len);

\#endif

74HC595驱动程序，说白了就是往74HC595发送数据

\#include "595.h"

\#include "spi.h"

void delay(uint16\_t t);

/\*\*\*\*\*\*\*\*  74HC595 GPIO 配置 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

void HC595\_GPIO\_Config(void)

GPIO\_InitTypeDef GPIO\_InitStructure;

RCC\_APB2PeriphClockCmd( SHCP\_GPIO\_CLK | STCP\_GPIO\_CLK | DS\_GPIO\_CLK, ENABLE);

GPIO\_InitStructure.GPIO\_Mode = GPIO\_Mode\_Out\_PP;

GPIO\_InitStructure.GPIO\_Speed = GPIO\_Speed\_2MHz;

GPIO\_InitStructure.GPIO\_Pin = SHCP\_GPIO\_PIN;

GPIO\_Init(SHCP\_GPIO\_PORT, &GPIO\_InitStructure);   // 初始化 SHCP 引脚

GPIO\_InitStructure.GPIO\_Pin = STCP\_GPIO\_PIN;

GPIO\_Init(STCP\_GPIO\_PORT, &GPIO\_InitStructure);   // 初始化 STCP 引脚

GPIO\_InitStructure.GPIO\_Pin = DS\_GPIO\_PIN;

GPIO\_Init(DS\_GPIO\_PORT, &GPIO\_InitStructure);     // 初始化 DS   引脚

//GPIO\_ResetBits(SHCP\_GPIO\_PORT, SHCP\_GPIO\_PIN);  // 引脚初始状态为高，便于产生上升沿

GPIO\_ResetBits(SHCP\_GPIO\_PORT, SHCP\_GPIO\_PIN);    // 引脚初始状态为低，便于产生上升沿

GPIO\_ResetBits(STCP\_GPIO\_PORT, STCP\_GPIO\_PIN);

GPIO\_ResetBits(DS\_GPIO\_PORT, DS\_GPIO\_PIN);

/\*\*\*

\*74HC595 发送一个字节

\*即往74HC595的DS引脚发送一个字节

\*/

void HC595\_Send\_Byte(u8 byte)

u8 i;

for (i = 0; i < 8; i ++)  //一个字节8位，传输8次，一次一位，循环8次，刚好移完8位

/\*\*\*\*  步骤1：将数据传到DS引脚    \*\*\*\*/

if (byte & 0x80)        //先传输高位，通过与运算判断第八是否为1

HC595\_Data\_High();    //如果第八位是1，则与 595 DS连接的引脚输出高电平

else                    //否则输出低电平

HC595\_Data\_Low();

/\*\*\* 步骤2：SHCP每产生一个上升沿，当前的bit就被送入移位寄存器 \*\*\*/

HC595\_SHCP\_Low();   // SHCP拉低

delay(1);           // 适当延时

HC595\_SHCP\_High();  // SHCP拉高， SHCP产生上升沿

delay(1);

byte <<= 1;     // 左移一位，将低位往高位移，通过    if (byte & 0x80)判断低位是否为1

/\*\*

\*74HC595输出锁存 使能

\*\*/

void HC595\_CS(void)

/\*\*  步骤3：STCP产生一个上升沿，移位寄存器的数据移入存储寄存器  \*\*/

HC595\_STCP\_Low();   // 将STCP拉低

delay(1);           // 适当延时

HC595\_STCP\_High();  // 再将STCP拉高，STCP即可产生一个上升沿

delay(1);

/\*\*

\*发送多个字节

\*便于级联时数据的发送

\*级联N级，就需要发送N个字节控制HC595

\*\*\*/

void HC595\_Send\_Multi\_Byte(u8 \*data, u16 len)

u8 i;

for (i = 0; i < len; i ++ ) // len 个字节

HC595\_Send\_Byte(data\[i\]);

HC595\_CS(); //先把所有字节发送完，再使能输出

void delay(uint16\_t t)

for (; t != 0; t --);

\#include "stm32f10x.h"

//\#include "spi.h"

\#include "595.h"

\#include "SysTick.h"

u8 pos; // led位置

u8 Led\_Pos\_Buf\[2\] = \{0x00, 0x00\}; //存储要发送的指令字节

//第pos个led亮：1     2    3      4    5     6     7     8

u8 Led\[32\] = \{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, //控制第二级74HC595

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //第一级的led全灭

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //第二级的led全灭

0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80\};//控制第一级74HC595

int main(void)

//  SPI\_Config();

HC595\_GPIO\_Config();

SysTick\_Init();

while(1)

for (pos = 0; pos < 16; pos ++) //第pos个灯，实现流水灯效果

SysTick\_Delay\_Ms(500);  //延时500毫秒

Led\_Pos\_Buf\[1\] = Led\[pos\];//存放第一级74HC595数据，因为先进先出，所以第一级放在Led\_Pos\_Buf\[1\]，而不是Led\_Pos\_Buf\[0\]

Led\_Pos\_Buf\[0\] = Led\[pos+16\]; //存放第二级74HC595的数据

HC595\_Send\_Multi\_Byte(Led\_Pos\_Buf,2);//将当前数据发送到595

**8 74HC595****级联电路编程（SPI控制）**

前一篇是讲用IO口模拟74HC595的时序来控制的，因为74HC595刚好也是串行输入的，所以直接用串行总线SPI来控制，大概说下电路的连接，SPI2的SCK引脚连接74HC595的SHCP引脚，SPI2的CS引脚连接74HC595的STCP引脚，SPI2的MOSI引脚连接74HC595的DS引脚，因为74HC595是没有数据返回给MCU的，所以SPI2的MISO引脚并不需要连接。

下面就把代码放上来，代码很简单，直接使用SPI发送数据就可以了。

开发平台：MDK5.14

MCU：STM32F103ZET6

SPI2头文件

\#ifndef \_\_SPI\_H

\#define \_\_SPI\_H

\#include "stm32f10x.h"

/\*SPI接口定义-开头\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

//\#define      SPIx                        SPI1

//\#define      SPI\_APBxClock\_FUN          RCC\_APB2PeriphClockCmd

//\#define      SPI\_CLK                     RCC\_APB2Periph\_SPI1

\#define      SPIx                        SPI2

\#define      SPI\_APBxClock\_FUN          RCC\_APB1PeriphClockCmd

\#define      SPI\_CLK                     RCC\_APB1Periph\_SPI2

//CS(NSS)引脚 片选选普通GPIO即可

\#define      SPI\_CS\_APBxClock\_FUN       RCC\_APB2PeriphClockCmd

\#define      SPI\_CS\_CLK                  RCC\_APB2Periph\_GPIOB

\#define      SPI\_CS\_PORT                 GPIOB

\#define      SPI\_CS\_PIN                  GPIO\_Pin\_12

//SCK引脚

\#define      SPI\_SCK\_APBxClock\_FUN      RCC\_APB2PeriphClockCmd

\#define      SPI\_SCK\_CLK                 RCC\_APB2Periph\_GPIOB

\#define      SPI\_SCK\_PORT                GPIOB

\#define      SPI\_SCK\_PIN                 GPIO\_Pin\_13

//MISO引脚

\#define      SPI\_MISO\_APBxClock\_FUN     RCC\_APB2PeriphClockCmd

\#define      SPI\_MISO\_CLK                RCC\_APB2Periph\_GPIOB

\#define      SPI\_MISO\_PORT               GPIOB

\#define      SPI\_MISO\_PIN                GPIO\_Pin\_14

//MOSI引脚

\#define      SPI\_MOSI\_APBxClock\_FUN     RCC\_APB2PeriphClockCmd

\#define      SPI\_MOSI\_CLK                RCC\_APB2Periph\_GPIOB

\#define      SPI\_MOSI\_PORT               GPIOB

\#define      SPI\_MOSI\_PIN                GPIO\_Pin\_15

\#define         SPI\_CS\_LOW()         GPIO\_ResetBits( SPI\_CS\_PORT, SPI\_CS\_PIN )

\#define         SPI\_CS\_HIGH()        GPIO\_SetBits( SPI\_CS\_PORT, SPI\_CS\_PIN )

/\*SPI接口定义-结尾\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

void SPI\_Config(void);

u8 SPI\_Read\_Send\_Byte(u8 byte);

u16 SPI\_Read\_Send\_HalfWord(u16 HalfWord);

void SPI\_Send\_Byte(u8 byte);

void SPI\_Send\_Multi\_Byte(u8 \*data, u16 len);

\#endif /\* \_\_SPI\_H \*/

SPI2

\#include "spi.h"

/\*\*

\* @brief  SPI\_FLASH初始化

\* @param  无

\* @retval 无

\*/

void SPI\_Config(void)

SPI\_InitTypeDef  SPI\_InitStructure;

GPIO\_InitTypeDef GPIO\_InitStructure;

/\* 使能SPI时钟 \*/

SPI\_APBxClock\_FUN ( SPI\_CLK, ENABLE );

/\* 使能SPI引脚相关的时钟 \*/

SPI\_CS\_APBxClock\_FUN ( SPI\_CS\_CLK|SPI\_SCK\_CLK|SPI\_MISO\_PIN|SPI\_MOSI\_PIN, ENABLE );

/\* 配置SPI的 CS引脚，普通IO即可 \*/

GPIO\_InitStructure.GPIO\_Pin = SPI\_CS\_PIN;

GPIO\_InitStructure.GPIO\_Speed = GPIO\_Speed\_2MHz;

GPIO\_InitStructure.GPIO\_Mode = GPIO\_Mode\_Out\_PP;

GPIO\_Init(SPI\_CS\_PORT, &GPIO\_InitStructure);

/\* 配置SPI的 SCK引脚\*/

GPIO\_InitStructure.GPIO\_Pin = SPI\_SCK\_PIN;

GPIO\_InitStructure.GPIO\_Mode = GPIO\_Mode\_AF\_PP;

GPIO\_Init(SPI\_SCK\_PORT, &GPIO\_InitStructure);

/\* 配置SPI的 MISO引脚\*/

GPIO\_InitStructure.GPIO\_Pin = SPI\_MISO\_PIN;

GPIO\_Init(SPI\_MISO\_PORT, &GPIO\_InitStructure);

/\* 配置SPI的 MOSI引脚\*/

GPIO\_InitStructure.GPIO\_Pin = SPI\_MOSI\_PIN;

GPIO\_Init(SPI\_MOSI\_PORT, &GPIO\_InitStructure);

/\* 停止信号CS引脚高电平\*/

SPI\_CS\_HIGH();

SPI\_InitStructure.SPI\_Direction = SPI\_Direction\_2Lines\_FullDuplex;

SPI\_InitStructure.SPI\_Mode = SPI\_Mode\_Master;

SPI\_InitStructure.SPI\_DataSize = SPI\_DataSize\_8b;

SPI\_InitStructure.SPI\_CPOL = SPI\_CPOL\_High;

SPI\_InitStructure.SPI\_CPHA = SPI\_CPHA\_2Edge;

SPI\_InitStructure.SPI\_NSS = SPI\_NSS\_Soft;

SPI\_InitStructure.SPI\_BaudRatePrescaler = SPI\_BaudRatePrescaler\_64;

SPI\_InitStructure.SPI\_FirstBit = SPI\_FirstBit\_MSB;

SPI\_InitStructure.SPI\_CRCPolynomial = 7;

SPI\_Init(SPIx , &SPI\_InitStructure);

SPI\_Cmd(SPIx , ENABLE);

u8 SPI\_Read\_Send\_Byte(u8 byte)

while (SPI\_I2S\_GetFlagStatus(SPIx , SPI\_I2S\_FLAG\_TXE) == RESET);

SPI\_I2S\_SendData(SPIx , byte);

while (SPI\_I2S\_GetFlagStatus(SPIx , SPI\_I2S\_FLAG\_RXNE) == RESET);

return SPI\_I2S\_ReceiveData(SPIx);

u16 SPI\_Read\_Send\_HalfWord(u16 HalfWord)

while (SPI\_I2S\_GetFlagStatus(SPIx , SPI\_I2S\_FLAG\_TXE) == RESET);

SPI\_I2S\_SendData(SPIx , HalfWord);

while (SPI\_I2S\_GetFlagStatus(SPIx , SPI\_I2S\_FLAG\_RXNE) == RESET);

return SPI\_I2S\_ReceiveData(SPIx );

// 在驱动74HC595只需要SPI的发送函数，并没用到读取函数

void SPI\_Send\_Byte(u8 byte)  //发送一个字节

while (SPI\_I2S\_GetFlagStatus(SPIx , SPI\_I2S\_FLAG\_TXE) == RESET)\{\}

SPI\_I2S\_SendData(SPIx , byte);

while (SPI\_I2S\_GetFlagStatus(SPIx , SPI\_I2S\_FLAG\_RXNE) == RESET);

SPI\_I2S\_ReceiveData(SPIx);

void SPI\_Send\_Multi\_Byte(u8 \*data, u16 len)  //连续发送 len 个字节

u8 i;

SPI\_CS\_LOW();

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

SPI\_Send\_Byte(data\[i\]);

SPI\_CS\_HIGH();  // STCP产生上升沿

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*END OF FILE\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

主函数

\#include "stm32f10x.h"

\#include "spi.h"

//\#include "595.h"

\#include "SysTick.h"

u8 pos; // led位置

u8 Led\_Pos\_Buf\[2\] = \{0x00, 0x00\}; //存储要发送的指令字节

//第pos个led亮：1     2    3      4    5     6     7     8

u8 Led\[32\] = \{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, //控制第二级74HC595

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //第一级的led全灭

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //第二级的led全灭

0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80\};//控制第一级74HC595

int main(void)

SPI\_Config();

//      HC595\_GPIO\_Config();

SysTick\_Init();

while(1)

for (pos = 0; pos < 16; pos ++) //第pos个灯，实现流水灯效果

SysTick\_Delay\_Ms(500);  //延时500毫秒

Led\_Pos\_Buf\[1\] = Led\[pos\]; //存放第一级74HC595的数据，因为先进先出，所以第一级放在Led\_Pos\_Buf\[1\]，而不是Led\_Pos\_Buf\[0\]

Led\_Pos\_Buf\[0\] = Led\[pos+16\]; //存放第二级74HC595的数据

SPI\_Send\_Multi\_Byte(Led\_Pos\_Buf,2);//将当前数据发送到595

参考文献：

[https://blog.csdn.net/k1ang/article/details/80012686][https_blog.csdn.net_k1ang_article_details_80012686]

[https://blog.csdn.net/k1ang/article/details/80012463][https_blog.csdn.net_k1ang_article_details_80012463]

参考设计图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 8][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70]: /images/20221119/3c2b58a757d44dd09ed7a5d3c50cd432.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 1]: /images/20221119/c520970a7f0a417ebdce71894218a1c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 2]: /images/20221119/4e29fe36e3b94225878eb92035652e82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 3]: /images/20221119/8e4cd4a8edb84083a21685de93f25b9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 4]: /images/20221119/95b63786c52e4e548f3b2aeab3945327.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 5]: /images/20221119/ae20a364b1ef4be1b49e3f1d3f2a132b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 6]: /images/20221119/3eb8b802160d4180859a963746a21c91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 7]: /images/20221119/557de2a124b74a37bb67d87f90a96ead.png
[https_blog.csdn.net_k1ang_article_details_80012686]: https://blog.csdn.net/k1ang/article/details/80012686
[https_blog.csdn.net_k1ang_article_details_80012463]: https://blog.csdn.net/k1ang/article/details/80012463
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p3ajY5NTUzNTEwMA_size_16_color_FFFFFF_t_70 8]: /images/20221119/e9798a77dce44c32926679ba5bcfd38c.png