• 【51单片机】7-LED点阵

    参考博客：

    3.7 51单片机-LED 16*16点阵-腾讯云开发者社区-腾讯云

    7.4 单片机 LED 点阵的图形显示 - 单片机教程(二) - UDN开源文档

    1.LED点阵简介

    1.什么是LED点阵

    1.外观

    2.作用

    3.内部构造原理图

    点阵的优势：就是8+8个IO口独立控制8*8个LED灯亮灭

    2.如何驱动LED点阵--74HC595

    2.1 单片机端口直接驱动

    要驱动8*8的点阵需要2个IO端口，（16个IO口），要驱动16*16点阵需要4个IO端口（32个IO口）

    2.2 使用串转并移位锁存器驱动：类似于队列【串入并出】

    SER  10101100 同一个引脚不同的时间送进来，串入（串行输入）--》在一个一个进入的时候其他位是不会改变的

    QA   1                同时在不同引脚输出，并出（并行输出）--》一起出去

    QB    0

    QC   1

    QD   0

    QE    1

    QF   1

    QG   0 

    QH    0

    2.3 为什么使用74HC595可以减少IO口的使用

    因为74HC595中有一个输入端口“SER”，这个端口是一个一个的输入，一共输入8个二进制数，在一次性输入完8个二进制数后，将其分配给QA-QH这8个端口，这时候这8给段码端就有了IO口，就不需要再去连接mcu的端口。

    使用串转并移位锁存驱动。要驱动16*16点阵只需要4个74HC595+1个IO端口。

    实际上只需要（数据口SRE，SCLK（寄存器时钟信号），SRCLK（串行时钟信号）+4个74HC595就可以点亮点阵）

    2.4 SCLK （寄存器时钟信号）  VS   SRCLK（串行时钟信号）

    2.5 74HC595数据传输方式

    1. 串行数据输入（DS）： 数据从外部输入到74HC595的DS引脚。数据以串行方式按位传输到芯片中。在传输数据时，通过SRCLK（Serial Clock）信号控制数据的移位。

    2. 时钟信号（SRCLK）： SRCLK是串行时钟信号，它控制数据的串行输入时序。每次SRCLK信号的上升沿，串行输入的数据就会按位移动到移位寄存器中。

    3. 存储寄存器时钟（RCLK）： RCLK是寄存器时钟信号，也称为存储寄存器时钟。一旦所有的串行数据被移位到移位寄存器中，通过RCLK信号的上升沿，将整个移位寄存器的数据一次性加载到存储寄存器中。

    4. 并行数据输出（Q7'~Q0）： 74HC595有8个并行输出引脚（Q7'~Q0），它们连接到外部电路。一旦数据被加载到存储寄存器中，通过并行时钟信号PCLK（Parallel Clock）的上升沿，将存储寄存器的数据并行输出到这些引脚上。

    5. 清零引脚（MR）： 74HC595通常还有一个清零引脚（MR，Master Reset），通过对MR引脚的操作可以清零寄存器中的数据。

    2.原理图分析

    1.POS1-16和NEG1-16分别接移位锁存器并行输出端

    （1）POS就是Positive 正极 ，NEG：negetive负极

    2.74HC595的接法分析

    （1）QA-QH8路并行输出接到点阵的一个端口

    （2）【QH’】这个串行输出口接下一个74HC595的串行输入SER（串联顺序按照ABCD）

    （3）SER串行输入接：第一个595的SER通过接J24的SER，后面的每一个SER都接入前面的【QH‘】。这样构成了ABCD4个595芯片依次串联。【所以将来编程整个4个74HC595的串行数据都是从J24的SER出来的】

    （4）SCLK（SRCLK）接J24的2

    （5）RCLK接J24的1

    3. 总结

    （1）SCLK和RCLK是一样的接法，都接再J24上

    （2）总共涉及到的IO端口就3个（J24连接mcu的三个，可以自己连接）

    （3）外部接线重点：2个8pin杜邦线+3个端口连接muc接口

    4.外部跳线接法

    3.LED点阵编程实践

    1. 74HC595 的时序分析

    （1）芯片与芯片之间的通信，都是通过一定的时序进行的。

    （2）时序就是芯片与芯片之间的通信引脚上电平变化以时间轴为参考的变化顺序。

    （3）时序是通信双方事先定义好的，通信的发送方必须按照时序来发送有意义的信息，通信的接收方按照时序去接收解析发送方发来的电平变化信息，然后就知道发送方要给我们发送什么东西。

    （4）我们编程时候：发送方是单片机，接收方是74HC595。因为595芯片本身是不能编程的，他的时序芯片出厂时候已经设置好，因此我们单片机必须按照595芯片的时序来发送信息

    （5）所以我们要先搞清楚74HC595的时序规则。595芯片手册上有它的时序描述（时序图），参考描述就可以明白595芯片的时序规则，然后将其编程语言表达出来即可。

    SCLK和RCLK

    （6）74HC595的时序的关键：SCLK和RCLK。

    SCLK是移位时钟，595芯片再每一个SCKL的上升沿会对SER引脚进行依次采样输入【判断此时是高电平还是低电平】。就向595内部输入1位，如此循环8次就输入了8位二进制。RCLK是锁存时钟，QA-QH的8位并行输出信号再RCLK的上升沿进行一次锁存更新。

    RCLK是锁存时钟，QA-QH的8位并行输出信号再RCLK的上升沿进行一次锁存更新。【要4个8bit全部输入后才可以进行一次锁存】

    SCLK和RCLK，SER

    SER：进行数据的串行输入

    SCLK：提供移位时钟【就是对上升沿的读取，判断是高电平还是低电平】---不进行锁存，数据还是会输出，但是数据不会再变，除非再锁存一次，才会改变。

    RCLK：提供锁存时钟【如果SER输入满8位二进制，则就进行一次锁存，第9位进入时，只能通过【QH’】将新进入的二进制移动到下一个74HC595上。】--->锁存是等四个HC595的并行数据存放好才可以锁存--->4个595芯片同时再进行锁存，各自锁存住了自己的数据--->才会亮

    SER进行数据的串行输入

    SCLK提供移位时钟--->上升沿移动

    RCLK提供锁存时钟---->上升沿锁存

    2.sbit定义位变量

    （1）之前的编程都是直接操作一个IO端口，可以用端口号（P0，P1）来整体操作一个IO端口中的8个引脚。但是这种方法不能操作单独一个IO口。

    （2）今天需要单独操作一个IO引脚，比如要操作P1.3,但是直接写P1.3C语言不认识，而必须使用sbit关键字来定义一个引脚。

    sbit SER = P1^3;//SER引脚名字

    1. #include
    2.  
    3. sbit RCLK =P0^0;  //74HC595的串行输入端
    4. sbit SCLK=P0^1;  //锁存时钟
    5. sbit SER=P0^2;  //移位时钟
    6.  
    7. /**
    8. 	点亮整个LED灯
    9. */
    10.  
    11. int main(){
    12. 	
    13. 	unsigned char i=0;
    14. 	//一个值是8位
    15. 	unsigned char d1,d2,d3,d4;//要给4个595进行输出端输出的值
    16. 	
    17. 	//根据原理图可以知道d1和d2是连接负极，所以要输入d1和d2的是0才会亮
    18. 	d1=0;
    19. 	d2=0;
    20. 	//因为根据原理图中可以知道d3和d4连接的是正极，所以输入的d3和d4要为全1才亮
    21. 	d3=0xff;
    22. 	d4=0xff;
    23. 	
    24. 	//一开始就将两个置为低电平
    25. 	//防止一进来就是高电平
    26. 	SCLK=0;
    27. 	RCLK=0;
    28. 	
    29. 	for(i=0;i<8;i++){
    30. 		
    31. 		//SCLK=0;---》可以的
    32. 		SER=d1>>7;//将d1的最高bit取出来给SER
    33. 		SCLK=0;
    34. 		//这句话：是上升沿，只要再上上升沿前出去最后一位，就可以
    35. 		SCLK=1;	//这2步制造了一个SCLK上升沿，在此时记录下这个数值，后面推进QA-QH中
    36. 		
    37. 		//将第二个进来的位数，变成最高位
    38. 		d1=d1<<1;
    39. 		
    40. 	}
    41. 	//至此已经再8个SCLK上升沿把d1的8位依次全部发出去了
    42. 	//但是还没有进行锁存，所以QA-QH还没有东西
    43. 	
    44. 	
    45. 	for(i=0;i<8;i++){
    46. 		
    47. 		SER=d2>>7;//将d2的最高bit取出来给SER
    48. 		SCLK=0;
    49. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    50. 		
    51. 		//将第二个进来的位数，变成最高位
    52. 		d2=d2<<1;
    53. 		
    54. 	}
    55. 	//至此已经把d1和d2都已经发出去了，并且d1已经被d2挤到第2个595芯片里面去了
    56. 	//此时595A中存放的是d2，595B中存放的是d1
    57. 	//但是还没有进行锁存，所以QA-QH还没有东西
    58. 	
    59. 		for(i=0;i<8;i++){
    60. 		
    61. 		SER=d3>>7;//将d3的最高bit取出来给SER
    62. 		SCLK=0;
    63. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    64. 		
    65. 		//将第二个进来的位数，变成最高位
    66. 		d3=d3<<1;
    67. 		
    68. 	}
    69. 	//至此已经把d1和d2和d3都已经发出去了，并且d1已经被d2和d3挤到第3个595芯片里面去了
    70. 	//此时595A中存放的是d3,595B中存放的是d2，595c中存放的是d1
    71. 	//但是还没有进行锁存，所以QA-QH还没有东西
    72. 	
    73. 		for(i=0;i<8;i++){
    74. 		
    75. 		SER=d4>>7;//将d4的最高bit取出来给SER
    76. 		SCLK=0;
    77. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    78. 		
    79. 		//将第二个进来的位数，变成最高位
    80. 		d4=d4<<1;
    81. 		
    82. 	}
    83. 	//至此已经把d1和d2和d3和d4都已经发出去了，并且d1已经被d2和d3和d4挤到第4个595芯片里面去了
    84. 	//此时595A中存放的是d4,595B中存放的是d3，595C中存放的是d2，595D中存放的是d1,
    85. 	//但是还没有进行锁存，所以QA-QH还没有东西
    86. 	
    87. 	//截至到这里，4个字节的数据d1，d2，d3，d4已经顺着74HC595的SER-》QH‘的串行输出
    88. 	//串行输出电路，已经爬满了4个74HC595（最先送出去的到了最后没一个595中）
    89. 	//但是到目前为止，4个595的QA-QH还没有出现锁存，点阵自然不会亮
    90. 	
    91. 	//然后要进行一次锁存，4个595芯片同时再进行锁存，各自锁存住了自己的数据
    92. 	RCLK=0;
    93. 	RCLK=1;
    94. 	//这两句之后595就完成了锁存，d1-d4就会影响4个595芯片的并行输出端，
    95. 	//进而会影响LED的正负极的值，然后LED就会亮或者灭
    96. 	
    97. 	//按照我们写的程序，d1和d2是负极，d3和d4是正极【原理图中有】
    98. 	
    99. }

    使用函数

    1. #include
    2.  
    3. sbit RCLK =P0^0;  //74HC595的串行输入端
    4. sbit SCLK=P0^1;  //锁存时钟
    5. sbit SER=P0^2;  //移位时钟
    6.  
    7.  
    8. //如果函数写在main后面，记得声明
    9. void SendData(unsigned char d1,unsigned char d2,unsigned char d3,unsigned char d4);
    10.  
    11.  
    12.  
    13. void SendData(unsigned char d1,unsigned char d2,unsigned char d3,unsigned char d4){
    14. 	
    15. 	unsigned char i=0;
    16. 	
    17. 	//一开始就将两个置为低电平
    18. 	SCLK=0;
    19. 	RCLK=0;
    20. 	
    21. 	for(i=0;i<8;i++){
    22. 		
    23. 		//SCLK=0;---》可以的
    24. 		SER=d1>>7;//将d1的最高bit取出来给SER
    25. 		SCLK=0;
    26. 		//这句话：是上升沿，只要再上上升沿前出去最后一位，就可以
    27. 		SCLK=1;	//这2步制造了一个SCLK上升沿，在此时记录下这个数值，后面推进QA-QH中
    28. 		
    29. 		//将第二个进来的位数，变成最高位
    30. 		d1=d1<<1;
    31. 		
    32. 	}
    33. 	//至此已经再8个SCLK上升沿把d1的8位依次全部发出去了
    34. 	//但是还没有进行锁存，所以QA-QH还没有东西
    35. 	
    36. 	
    37. 	for(i=0;i<8;i++){
    38. 		
    39. 		SER=d2>>7;//将d2的最高bit取出来给SER
    40. 		SCLK=0;
    41. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    42. 		
    43. 		//将第二个进来的位数，变成最高位
    44. 		d2=d2<<1;
    45. 		
    46. 	}
    47. 	//至此已经把d1和d2都已经发出去了，并且d1已经被d2挤到第2个595芯片里面去了
    48. 	//此时595A中存放的是d2，595B中存放的是d1
    49. 	//但是还没有进行锁存，所以QA-QH还没有东西
    50. 	
    51. 		for(i=0;i<8;i++){
    52. 		
    53. 		SER=d3>>7;//将d3的最高bit取出来给SER
    54. 		SCLK=0;
    55. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    56. 		
    57. 		//将第二个进来的位数，变成最高位
    58. 		d3=d3<<1;
    59. 		
    60. 	}
    61. 	//至此已经把d1和d2和d3都已经发出去了，并且d1已经被d2和d3挤到第3个595芯片里面去了
    62. 	//此时595A中存放的是d3,595B中存放的是d2，595c中存放的是d1
    63. 	//但是还没有进行锁存，所以QA-QH还没有东西
    64. 	
    65. 		for(i=0;i<8;i++){
    66. 		
    67. 		SER=d4>>7;//将d4的最高bit取出来给SER
    68. 		SCLK=0;
    69. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    70. 		
    71. 		//将第二个进来的位数，变成最高位
    72. 		d4=d4<<1;
    73. 		
    74. 	}
    75. 	//至此已经把d1和d2和d3和d4都已经发出去了，并且d1已经被d2和d3和d4挤到第4个595芯片里面去了
    76. 	//此时595A中存放的是d4,595B中存放的是d3，595C中存放的是d2，595D中存放的是d1,
    77. 	//但是还没有进行锁存，所以QA-QH还没有东西
    78. 	
    79. 	//截至到这里，4个字节的数据d1，d2，d3，d4已经顺着74HC595的SER-》QH‘的串行输出
    80. 	//串行输出电路，已经爬满了4个74HC595（最先送出去的到了最后没一个595中）
    81. 	//但是到目前为止，4个595的QA-QH还没有出现锁存，点阵自然不会亮
    82. 	
    83. 	//然后要进行一次锁存，4个595芯片同时再进行锁存，各自锁存住了自己的数据
    84. 	RCLK=0;
    85. 	RCLK=1;
    86. 	//这两句之后595就完成了锁存，d1-d4就会影响4个595芯片的并行输出端，
    87. 	//进而会影响LED的正负极的值，然后LED就会亮或者灭
    88. 	
    89. 	//按照我们写的程序，d1和d2是负极，d3和d4是正极【原理图中有】
    90. }
    91.  
    92. void main(){
    93. 	
    94. 	//因为d1和d2在595芯片中连接的是正电极，所以我们要输入0才会形成电压差
    95. 	//d3和d4是连接负电极，所以我们要输入1才会形成电压差
    96. 	SendData(0x00,0x00,0xff,0xff);
    97. }

    3.宏定义和的引入和uchar,u8

    #define u8 unsigned char
    #define u16 unsigned short
    #define u32 unsigned int

    1. /**
    3. 	使用自定义的宏定义
    4. */
    5.  
    6. //自定义宏定义
    7. #define uchar unsigned char   //#define 要尽量靠前，而且没有分号
    8. #define u8 unsigned char
    9. #define u16 unsigned short
    10. #define u32 unsigned int
    11.  
    12.  
    13. //如果函数写在main后面，记得声明
    14. //void SendData(unsigned char d1,unsigned char d2,unsigned char d3,unsigned char d4);
    15.  
    16. void SendData(uchar d1,uchar  d2,uchar d3,uchar d4);

    4.对点阵点亮规律探索

    P1，P2控制列，P3，P4控制行的

    1.编程点亮最上面一排:SendData(0x00,0x00,0x00,0x01)

    2.编程点亮最下面一排:SendData(0x00,0x00,0x80,0x00);

    3.编程点亮最左面一排：SendData(0xff,0xfe,0xff,0xff)

    4.编程点亮最右面一排：SendData(0x7f,0xff,0xff,0xff)

    5.点亮上半屏:SendData(0x00,0x00,0x00,0xff)

    因为d1和d2在原理图上是对应负极，d3和d4应该输入正极

    d1对应着NEG9-16，d2对应着NEG1-8，d3对应着POS9-16，d4对应着POS1-8

    1. #include
    2. /**
    4. 	使用自定义的宏定义
    5. */
    6.  
    7. //自定义宏定义
    8. #define uchar unsigned char
    9.  
    10. sbit RCLK =P0^0;  //74HC595的串行输入端
    11. sbit SCLK=P0^1;  //锁存时钟
    12. sbit SER=P0^2;  //移位时钟
    13.  
    14.  
    15. //如果函数写在main后面，记得声明
    16.  
    17. void SendData(uchar d1,uchar  d2,uchar d3,uchar d4);
    18.  
    19.  
    20.  
    21. void SendData(uchar d1,uchar d2,uchar d3,uchar d4){
    22. 	
    23. 	uchar i=0;
    24. 	
    25. 	//一开始就将两个置为低电平
    26. 	SCLK=0;
    27. 	RCLK=0;
    28. 	
    29. 	for(i=0;i<8;i++){
    30. 		
    31. 		//SCLK=0;---》可以的
    32. 		SER=d1>>7;//将d1的最高bit取出来给SER
    33. 		SCLK=0;
    34. 		//这句话：是上升沿，只要再上上升沿前出去最后一位，就可以
    35. 		SCLK=1;	//这2步制造了一个SCLK上升沿，在此时记录下这个数值，后面推进QA-QH中
    36. 		
    37. 		//将第二个进来的位数，变成最高位
    38. 		d1=d1<<1;
    39. 		
    40. 	}
    41. 	
    42. 	
    43. 	for(i=0;i<8;i++){
    44. 		
    45. 		SER=d2>>7;//将d2的最高bit取出来给SER
    46. 		SCLK=0;
    47. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    48. 		
    49. 		//将第二个进来的位数，变成最高位
    50. 		d2=d2<<1;
    51. 		
    52. 	}
    53. 	
    54. 		for(i=0;i<8;i++){
    55. 		
    56. 		SER=d3>>7;//将d3的最高bit取出来给SER
    57. 		SCLK=0;
    58. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    59. 		
    60. 		//将第二个进来的位数，变成最高位
    61. 		d3=d3<<1;
    62. 		
    63. 	}
    64. 	
    65. 		for(i=0;i<8;i++){
    66. 		
    67. 		SER=d4>>7;//将d4的最高bit取出来给SER
    68. 		SCLK=0;
    69. 		SCLK=1;	//这2步制造了一个SCLK上升沿
    70. 		
    71. 		//将第二个进来的位数，变成最高位
    72. 		d4=d4<<1;
    73. 		
    74. 	}
    75. 	RCLK=0;
    76. 	RCLK=1;
    77. }
    78.  
    79. void main(){
    80. 	SendData(0x00,0x00,0x00,0xff);//亮上半屏
    81. }

    6.点亮下半屏:SendData(0x00,0x00,0xff,0x00)

    7.点亮四个角：SendData(0x7f,0xfe,0x80,0x01)

    1. 	//亮四角的四颗
    2. 	//四颗：则d1对应9-16列，要求亮16列【最大的那个】（0亮1灭)
    3. 	//d2对应1-8列，要求亮第一列【最小的那个】（0亮1灭）
    4. 	//d3对应9-16行，要求亮最后一行【最大的那个】（1亮0灭）
    5. 	//d4对应1-8行，要求最上一行【最小的那个】（1亮0灭）
    6. 	SendData(0x7f,0xfe,0x80,0x01);

    8.点亮右上角：SendData(0x7f,0xff,0x00,0x01)

    5.总结

    （1）编写硬件控制代码，时序理解是关键。只要时序理解正确的，并且代码按照时序写

    （2）d1-d4都是最低bit位表示编号小是数字，比如d4的bit0对应1

    （3）d3和d4是正极，1亮0灭；d1和d2是负极，1灭0亮。

    6.点亮点阵的步骤

    1）先判断d1-d4应该输入什么值才能点亮【比如我们d1和d2是输入到595D和595C，我们查看原理图分析可知道，对应的是负极，则我们要输入0才会点亮led；d3和d4是对应595B和595D，对应的是正极，则输入0xff才会点亮led】

    2）SCLK：移位时钟。分析原理图，分别在什么时候才可以将数据输入并且存储到移动寄存器中。查看SCLK【移位时钟】。---》百度查看，只有在SCLK为上升沿的时候，才会将数据输入。

    3）RCLK：锁存时钟。这个是针对并行数据。当我们将四个并行寄存器都存储后，就需要将其锁起来，防止数据被修改。

    4.字模

    1.什么是字模

    （1）如何记录组成字的LED点阵亮灭信息（16*16点阵一共有256点，显示一共特定的字需要其中有一些点亮而另外一些不亮，如何记录哪些点亮哪一些点不亮？用字模）

    （2）字模如何工作？256个点用256个二进制位表示，1表示这个点亮，0表示不亮。256个点就是256个二进制位，也就是256/8=32个字节，所以一个大小位16*16的字的字模的32个字节大小。所以字模的表现形式就是32个unsigned char型数据。

    2.字模如何获取

    （1）一般通过专门的字模软件去提取，这种软件的可以得到这个字对应的32个字节的字模编码。

    （2）字模的结果不是唯一的，和你提取字模的方式有关（横向纵向）

    （3）提取字模时是没有标准的，怎么做都是对的或者都是错的，关键是你提取的这个字模的方式和你用来在点阵上显示这个字模的函数必须对应。

    3.字模软件的使用

    （1）使用方式：

                            第一步：先选择字形（实际开发板多大就选择多大）

                            第二步：选择合适的字体，字号等

                            第三步：选择编码方式和实际取模方式【D7-->D0】

                            第四步：直接将得到的结果取走

    4.字模手工分析和验证

    （1）手工对比字模内容和屏幕显示，从进行验证

    5.横向取模的显示

    因为我们横向取模是一行一行展示

    d1和d2是控制列，控制这列要显示哪一个点

    d3和d4是控制行，控制要显示哪一行--》则我们可以一行一行的遍历16次（行）

    SendData(~code[2*i+1],~code[2*i],hang[2*i],hang[2*i+1])

    1.普通方法

    1.按照取模软件的结果输入

    取模软件得出的结果是：1亮，0灭，但是我们d1和d2是接负极【应该是1灭0亮】，与我们想要的结果相反

    上面代码出现的问题：

    1）本来应该就亮一颗，结果就1颗不亮其他亮----》将取模结果取反

    2）亮的位置也不正确----》将2个8bit的位置对调位置

    2.将取模结果按位取反

    原来为1，取反变0；反之

    3.将d1与d2位置调换

    因为点在最右边，则可能是我们d1和d2的位置取反，则我们试着将其转换过来。

    4.多试几行

    1. /*--  文字:  林  --*/
    2. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
    3. 	//分析可知：
    4. 	//取模软件得出的结果是：1表示亮，0表示灭
    5. uchar zhu[32] = {
    6. 0x08,0x04,0x08,0x04,0x08,0x04,0x08,0x04,0xBF,0x7F,0x08,0x04,0x0C,0x0E,0x1C,0x0E,
    7. 0x2A,0x15,0x0A,0x15,0x89,0x24,0x48,0x44,0x28,0x04,0x08,0x04,0x08,0x04,0x08,0x04,
    8. };
    9.  
    10.  
    11.  
    12. int main() {
    13. 	//显示第一行
    14. 	//取模结果与我们想要的相反
    15. 	//SendData(0x80, 0x00, 0x00, 0x01);
    16. 	//则我们将结果取反
    17. 	//SendData(~0x80, ~0x00, 0x00, 0x01);
    18. 	//将d1与d2两者的值调换一下
    19. 	SendData(~0x04, ~0x08, 0x00, 0x01);			//第一行
    20. 	SendData(~0x04,~0x08,0x00,0x02);				//第二行
    21. 	
    22. 	SendData(~0x04,~0x08,0x00,0x04);				//第三行
    23. 	SendData(~0x04,~0x08,0x00,0x08);				//第四行
    24. 	SendData(~0x7F,~0xBF,0x00,0x10);				//第五行
    25. 	
    26. 	SendData(~0x04,~0x08,0x00,0x20);				//第6行
    27. 	
    28. 	SendData(~0x0E,~0x0C,0x00,0x40);				//第7行
    29. 	
    30. 	SendData(~0x0E,~0x1C,0x00,0x80);				//第8行
    31. 	
    32. 	SendData(~0x15,~0x2A,0x01,0x00);				//第9行
    33. 	
    34. 	SendData(~0x15,~0x0A,0x02,0x00);				//第10行
    35. 	
    36. 	SendData(~0x24,~0x89,0x04,0x00);				//第11行
    37. 	
    38. 	SendData(~0x44,~0x48,0x08,0x00);				//第12行
    39. 	
    40. 	SendData(~0x04,~0x28,0x10,0x00);				//第13行
    41. 	
    42. 	SendData(~0x04,~0x08,0x20,0x00);				//第14行
    43. 	
    44. 	SendData(~0x04,~0x08,0x40,0x00);				//第15行
    45. 	
    46. 	SendData(~0x04,~0x08,0x80,0x00);				//第16行
    47. }

    2.规律

    1. /*--  文字:  林  --*/
    2. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
    3. 	//分析可知：
    4. 	//取模软件得出的结果是：1表示亮，0表示灭
    5. uchar zhu[32] = {
    6. 0x08,0x04,0x08,0x04,0x08,0x04,0x08,0x04,0xBF,0x7F,0x08,0x04,0x0C,0x0E,0x1C,0x0E,
    7. 0x2A,0x15,0x0A,0x15,0x89,0x24,0x48,0x44,0x28,0x04,0x08,0x04,0x08,0x04,0x08,0x04,
    8. };

    （1）d1和d2用字模来填充，填充时要取反【d1=0x00,d2=0x80】-->因为d1和d2对应的是负极【0亮1灭】与取模软件【1亮0灭】给的相反

    （2）d3和d4来选择哪一个行被点亮，而d1和d2选择这行中哪一列被点亮

    （3）SendData一次送16个LED的亮灭信息（2字节），所以必须调用256/16=16次SendData函数，才能把整个点阵全部点亮完毕。

    （4）每一次调用SendData时，d1-d4变化是有规律的，因此有希望通过函数来调用SendData而不需要手工调用16次。

    3.通过数组实现

    1. #include
    2. /**
    4. 	横向取模：使用数组进行字的展示
    5. */
    6.  
    7. //自定义宏定义
    8. #define uchar unsigned char
    9.  
    10. sbit RCLK = P0 ^ 0;  //74HC595的串行输入端
    11. sbit SCLK = P0 ^ 1;  //锁存时钟
    12. sbit SER = P0 ^ 2;  //移位时钟
    13.  
    14.  
    15. //如果函数写在main后面，记得声明
    16.  
    17. void SendData(uchar d1, uchar  d2, uchar d3, uchar d4);
    18.  
    19.  
    20.  
    21. void SendData(uchar d1, uchar d2, uchar d3, uchar d4) {
    22.  
    23. 	uchar i = 0;
    24.  
    25. 	//一开始就将两个置为低电平
    26. 	SCLK = 0;
    27. 	RCLK = 0;
    28.  
    29. 	for (i = 0;i < 8;i++) {
    30.  
    31. 		//SCLK=0;---》可以的
    32. 		SER = d1 >> 7;//将d1的最高bit取出来给SER
    33. 		SCLK = 0;
    34. 		//这句话：是上升沿，只要再上上升沿前出去最后一位，就可以
    35. 		SCLK = 1;	//这2步制造了一个SCLK上升沿，在此时记录下这个数值，后面推进QA-QH中
    36.  
    37. 		//将第二个进来的位数，变成最高位
    38. 		d1 = d1 << 1;
    39.  
    40. 	}
    41.  
    42.  
    43. 	for (i = 0;i < 8;i++) {
    44.  
    45. 		SER = d2 >> 7;//将d2的最高bit取出来给SER
    46. 		SCLK = 0;
    47. 		SCLK = 1;	//这2步制造了一个SCLK上升沿
    48.  
    49. 		//将第二个进来的位数，变成最高位
    50. 		d2 = d2 << 1;
    51.  
    52. 	}
    53.  
    54. 	for (i = 0;i < 8;i++) {
    55.  
    56. 		SER = d3 >> 7;//将d3的最高bit取出来给SER
    57. 		SCLK = 0;
    58. 		SCLK = 1;	//这2步制造了一个SCLK上升沿
    59.  
    60. 		//将第二个进来的位数，变成最高位
    61. 		d3 = d3 << 1;
    62.  
    63. 	}
    64.  
    65. 	for (i = 0;i < 8;i++) {
    66.  
    67. 		SER = d4 >> 7;//将d4的最高bit取出来给SER
    68. 		SCLK = 0;
    69. 		SCLK = 1;	//这2步制造了一个SCLK上升沿
    70.  
    71. 		//将第二个进来的位数，变成最高位
    72. 		d4 = d4 << 1;
    73.  
    74. 	}
    75. 	RCLK = 0;
    76. 	RCLK = 1;
    77. }
    78.  
    79. /*--  文字:  铧  --*/
    80. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
    81. 	//分析可知：
    82. 	//取模软件得出的结果是：1表示亮，0表示灭
    83. uchar zhu[32] = {
    84. 0x08,0x09,0x08,0x29,0xBC,0x28,0x84,0x18,0xC2,0x08,0xBD,0x4C,0x88,0x4A,0x88,0x70,
    85. 0xBF,0x04,0x08,0x04,0xC8,0x7F,0x08,0x04,0x28,0x04,0x18,0x04,0x08,0x04,0x00,0x04,};
    86.  
    87. //2个一组，代表d3和d4--【1-16行】
    88. unsigned char hang[32]={
    89. 	0x00,0x01,0x00,0x02,0x00,0x04,0x00,0x08,
    90. 	0x00,0x10,0x00,0x20,0x00,040,0x00,0x80,
    91. 	0x01,0x00,0x02,0x00,0x04,0x00,0x08,0x00,
    92. 	0x10,0x00,0x20,0x00,0x40,0x00,0x80,0x00,
    93. };
    94.  
    95. int main() {
    96. 	
    97. 	uchar i=0;
    98. 	//因为每一次调用senddata的时候输入16位，但是一共有256，所以要输入16次
    99. 	for(i=0;i<16;i++){
    100. 		
    101. 		SendData(~zhu[2*i+1],~zhu[2*i],hang[2*i],hang[2*i+1]);//每一次亮一行
    102. 	}
    103. 	
    104. 	
    105. }

    4.通过函数实现

    1. void Display(uchar zimu[32],uchar hang[32]){
    2. 	
    3. 	
    4. 	uchar i=0;
    5. 	//因为每一次调用senddata的时候输入16位，但是一共有256，所以要输入16次
    6. 	for(i=0;i<16;i++){
    7. 		
    8. 		SendData(~zimu[2*i+1],~zimu[2*i],hang[2*i],hang[2*i+1]);//每一次亮一行
    9. 	}
    10. 	
    11. 	
    12. }
    13.  
    14. int main() {
    15. 	
    16. 	Display(zhu,hang);
    17. 	
    18. }

    6.纵向取模的显示

    （d1，d2，d3，d4）

    纵向取模则要修改的是列

    则d1和d2是控制显示哪一列--》所以我们可以使用一次数16列来进行递归

    d3和d4是控制要显示这一列的哪几个点

    SendData(lie[2*1],lie[2*i+1],code[i+16],code[i]);

    1.使用数组进行展示

    普通的显示最左边一列：SendData(0xff,0xfe,0xff,0xff)

    1. #include
    2. /**
    4. 	纵向取模：使用数组进行字的展示
    5. */
    6.  
    7. //自定义宏定义
    8. #define uchar unsigned char
    9.  
    10. sbit RCLK = P0 ^ 0;  //74HC595的串行输入端
    11. sbit SCLK = P0 ^ 1;  //锁存时钟
    12. sbit SER = P0 ^ 2;  //移位时钟
    13.  
    14.  
    15. //如果函数写在main后面，记得声明
    16.  
    17. void SendData(uchar d1, uchar  d2, uchar d3, uchar d4);
    18. void Display(uchar zimu[32],uchar lie[32]);
    19.  
    20.  
    21.  
    22. void SendData(uchar d1, uchar d2, uchar d3, uchar d4) {
    23.  
    24. 	uchar i = 0;
    25.  
    26. 	//一开始就将两个置为低电平
    27. 	SCLK = 0;
    28. 	RCLK = 0;
    29.  
    30. 	for (i = 0;i < 8;i++) {
    31.  
    32. 		//SCLK=0;---》可以的
    33. 		SER = d1 >> 7;//将d1的最高bit取出来给SER
    34. 		SCLK = 0;
    35. 		//这句话：是上升沿，只要再上上升沿前出去最后一位，就可以
    36. 		SCLK = 1;	//这2步制造了一个SCLK上升沿，在此时记录下这个数值，后面推进QA-QH中
    37.  
    38. 		//将第二个进来的位数，变成最高位
    39. 		d1 = d1 << 1;
    40.  
    41. 	}
    42.  
    43.  
    44. 	for (i = 0;i < 8;i++) {
    45.  
    46. 		SER = d2 >> 7;//将d2的最高bit取出来给SER
    47. 		SCLK = 0;
    48. 		SCLK = 1;	//这2步制造了一个SCLK上升沿
    49.  
    50. 		//将第二个进来的位数，变成最高位
    51. 		d2 = d2 << 1;
    52.  
    53. 	}
    54.  
    55. 	for (i = 0;i < 8;i++) {
    56.  
    57. 		SER = d3 >> 7;//将d3的最高bit取出来给SER
    58. 		SCLK = 0;
    59. 		SCLK = 1;	//这2步制造了一个SCLK上升沿
    60.  
    61. 		//将第二个进来的位数，变成最高位
    62. 		d3 = d3 << 1;
    63.  
    64. 	}
    65.  
    66. 	for (i = 0;i < 8;i++) {
    67.  
    68. 		SER = d4 >> 7;//将d4的最高bit取出来给SER
    69. 		SCLK = 0;
    70. 		SCLK = 1;	//这2步制造了一个SCLK上升沿
    71.  
    72. 		//将第二个进来的位数，变成最高位
    73. 		d4 = d4 << 1;
    74.  
    75. 	}
    76. 	RCLK = 0;
    77. 	RCLK = 1;
    78. }
    79.  
    80. /*--  文字:  朱  --*/
    81. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
    82. unsigned char zhu[32]={
    83. 0x80,0xA0,0x90,0x8E,0x88,0x88,0x88,0xFF,0x88,0x88,0x88,0x88,0x88,0x80,0x80,0x00,
    84. 0x20,0x20,0x10,0x08,0x04,0x02,0x01,0xFF,0x01,0x02,0x04,0x08,0x10,0x20,0x20,0x00};
    85.  
    86.  
    87.  
    88. unsigned char lie[32]={
    89. 	0xff,0xfe,0xff,0xfd,0xff,0xfb,0xff,0xf7,
    90. 	0xff,0xef,0xff,0xdf,0xff,0xbf,0xff,0x7f,
    91. 	0xfe,0xff,0xfd,0xff,0xfb,0xff,0xf7,0xff,
    92. 	0xef,0xff,0xdf,0xff,0xbf,0xff,0x7f,0xff
    93. 	
    94. 	
    95. };
    96.  
    97. void display(uchar zimu[32],uchar lie[32]){
    98.     SendData(lie[2*i],lie[2*i+1],zimu[i+16],zimu[i]);
    99. }
    100.  
    101. int main() {
    102. 	//普通方法
    103. 	
    104. 	//原来亮最左边一列
    105. 	//SendData(0xff,0xfe,0xff,0xff);
    106. 	//第一列的上半部分是字符串中的第一个
    107. 	//第一列的下半部分是字符串中的第17个
    108. 	//SendData(0xff,0xfe,0x80,0x20);//最左边一列
    109. 	//调换d3和d4的位置
    110. 	//SendData(0xff,0xfe,0x20,0x80);//最左边一列
    111. 	
    112. 	//使用递归
    113. 	uchar i=0;
    114. 	for(i=0;i<16;i++){
    115. 		SendData(lie[2*i],lie[2*i+1],zhu[i+16],zhu[i]);
    116. 		
    117. 	}
    118. }

    2.总结

    （1）获取取模软件输入进来的数组

    （2）最左边是：SendData(0xff,0xfe,0xff,0xff)

    （3）因为纵向排序是

    所以，我们列数的第一个的对应取模软件的第一个数值，第二列应该对应着取模软件的第十七个数值。

  • 相关阅读:
    关于：未同意隐私政策，应用获取ANDROID ID问题
    SSM-Spring-day3 AOP、事务管理
    除了「加机器」，其实你的微服务还能这样优化
    为什么 GraphQL 可以取代 Redux？
    【Verilog基础】“与/或/非”门级电路实现“2选1MUX”、“4选1MUX”、“8选1MUX”、“异或门”、“半加器”
    消息队列基本原理和选型对比
    小程序和前台开发软件定制的相关信息|APP网站搭建
    Qlik Sense : Fetching data with Qlik Web Connectors
    MyBatis-Plus 一些记录(1)
    【ARM CoreLink 系列 2 -- CCI-400 控制器简介】
  • 原文地址：https://blog.csdn.net/m0_63077733/article/details/133207885