前言
之前呢，考虑到要参加全国电子设计大赛，就专门投入到MSP430的学习海洋中去，结果延期了，那咱就先回归老本行，主要还是记录一下自己的收获嘛，暑假这段期间内除了特殊情况，我坚持每天写一篇博客，基本上我都会围绕STM32f1和MSP430F5529这两款单片机来，但是呢，要回家了嘛，所以不会把所有模块的演示图片都截上来，但是代码肯定会尽量按照自己的理解给大家讲一下，哪里讲的不对也恳请大家批评指正，谢谢。

一、8*8点阵

4 `6 S0 y/ z4 e" g; R/ G7 H2 a

其实，8*8点阵是一个很好上手的模块，原理也相当简单，它有6个接口，分别是GND、VCC、NC、CLK、LE、DI

其中GND和VCC就不说了，NC这个接口不用接线，常闭口，CLK移位时钟控制端，LE储存时钟控制端，DI数据输入控制端

简单来说吧，把CLK和LE位先拉低，再打开DI口（拉高），然后再设置8个循环写入数据，之后拉高CLK，处于上升沿状态来发送数据，然后置0，最后拉高LE锁存，然后置0。具体代码和取模方法下面再介绍。

0 l$ n* a9 _  K0 ?下图是演示：用的是系统板这里我是用PG0、1、2来接DI、LE、CLK
) Z7 X7 a2 ^2 E- A( v6 H


( A$ F' a7 h/ Z" Q* u8 W 后面学会了取模，就可以自己随意显示自己想要的东西了，自己画才有成就感。

7 O% l: U3 K# o# P二、显示代码详解
! D$ K8 f8 w. N3 p点阵头文件
7 x, F, U/ \9 _7 Y7 t3 d! ?+ ~% g' m3 a/ D
, _2 H7 t$ I- @3 r1 q" \

1. #ifndef __DZ_H
   
2. #define __DZ_H         
     |/ X5 L/ n2 \( l
3. #include "sys.h"
   
4. 
   3 x& j" v) J( i, i9 G$ J# ~/ P
5. #define LEDARRAY_DI   PGout(0)// DI
   : J2 t8 C. J# o; b/ C0 c
6. #define LEDARRAY_LAT  PGout(1)// LE
   
7. #define LEDARRAY_CLK  PGout(2)//CLK
   1 }" W% V, b* o" @0 B2 ]
8. 
   $ m+ b# x9 i+ g, K3 a; j
9. 
   
10. void Send_Byte( unsigned char dat);//发送字节
    
11. void DZ_Init(void);//点阵初始化
    
12. 
    % R& s* ^% H' @( r& l% j
13.                                                      
    0 C# f/ t) O' |7 k
14. #endif

复制代码

; b- y8 X3 `! ~/ R& K 点阵函数
2 {/ C& v  T" u: _4 z, v

1. #include "88dz.h"
   
2. #include "delay.h"
   
3. 
   
4. void DZ_Init()//初始化PG0、1、2
   + X5 I9 e! P( Q; n
5. {
   
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   
7.          
   4 q. O: Z. H( C8 R8 R; L
8. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG, ENABLE);        
   
9.         
   
10. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2;                                 
    
11. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 
    
12. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;               
    
13. GPIO_Init(GPIOG, &GPIO_InitStructure);                                         
    3 u- [# _' ^& K' n
14. GPIO_SetBits(GPIOG,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2);                                                
    
15. 
    . V& i: g; Q0 E7 e( q/ T- K
16. }
    . Q  x+ R% x8 M
17. void Send_Byte( unsigned char dat)
    
18. {
    " m2 q+ f6 i$ b' E& p: E
19.         unsigned char i;
    
20.         LEDARRAY_CLK = 0;//拉低
    
21.         LEDARRAY_LAT = 0;//拉低
    : ^6 ^& u: B7 r' a8 x! X
22.         for( i = 0 ; i < 8 ; i++ ) //循环8次发送字节
    4 g. @8 S0 X$ z( D- V- M6 c
23.         {
    
24.                 if( dat&0x01 )
    
25.                 {
    . m. ~- q7 O/ I* o: _2 Q6 ]. p; u
26.                         LEDARRAY_DI = 1;        
    7 n. T7 d' ]0 J9 V( ^2 V
27.                 }
    
28.                 else
    
29.                 {
    ( ^8 X' W+ f3 j$ h3 N" R7 |
30.                         LEDARRAY_DI = 0;
    
31.                 }
    ( R: ~* T3 ^4 U8 s, k; j
32.                
    
33.                 LEDARRAY_CLK = 1;                                //上升沿发送数据
    1 Q% M! m; d& |: c2 \2 O
34.                 LEDARRAY_CLK = 0;
    * m/ a& i0 i% l: L% w" r+ \3 _
35. 
    9 j6 ~, i/ t8 R1 g0 b: S6 n; P
36.                                 
    
37.                 dat >>= 1;                        
    & _+ r" p! u& m( c" ?
38.         }               
    . v& C0 i- w6 T9 m3 X7 x, ]
39.         
    5 n  A  b. q6 X4 f( `2 l5 c: E: l
40.         
    
41. }
    / c+ s0 `" \" d" i- Z% v

复制代码

主函数

1. #include "sys.h"
   1 l8 Z" ]# ]1 v. D% U7 B
2. #include "delay.h"
   
3. #include "led.h"
   4 A# R# K, y2 f7 Z  D* J6 ]
4. #include "88dz.h"
   
5. 
   
6. //这里自己可以自行更改
   0 X2 ]$ o' @: `9 |
7. unsigned char  Display_word[7][8] = {
   
8. 0x00,0x1C,0x14,0xFF,0x14,0x1C,0x00,0x00,//中
   $ F$ M( E1 N6 ]  ]4 Q
9. 0x00,0xFF,0x81,0xCB,0xFF,0xEB,0x81,0xFF,//国
   " {3 s  z1 j2 i9 R* i
10. 0x00,0x10,0x54,0x3F,0x14,0x3F,0x54,0x10,//共
    
11. 0x80,0x84,0xEC,0x35,0x26,0x34,0x2C,0x04,//产
    
12. 0x00,0x06,0x83,0xFA,0x2B,0xFA,0x83,0xC6,//党
    
13. 0x42,0x22,0x1E,0x0A,0x4A,0x4A,0x7A,0x02,//万
    2 \" ^2 L4 G1 E3 Y6 _9 i, c
14. 0x40,0x26,0x34,0xDC,0x57,0x34,0x14,0x06        //岁
    ' s& ^0 c7 ^' \; c! N5 |1 d$ g
15. };
    
16. 
    
17. int main(void)
    5 T: l8 j, K1 d* m
18. {        
    
19.         unsigned char k, temp;
    
20.     unsigned char i;
    & U/ s% D  j. q9 ~: l
21.         delay_init();         
    / w2 b* L0 g5 P% S5 L5 p
22.         LED_Init();                  
    
23.     DZ_Init();
    * s( i* _" t9 [' I8 `
24.          
    
25.         while(1)
    
26.         {
    
27. 
    2 \, B1 I  o0 D  M
28.         for(i=0;i<100;i++)//这里i<100的取值越大，显示时间越久
    
29.          {
      V/ n/ C& O" r* C/ w
30.                         temp = 0x7f;//接下来进行列选择
    
31.                         for(k = 0 ; k < 8 ; k++)               
    & ^3 a7 h8 U; V9 ?! ^
32.                         {
    
33.                                 Send_Byte(temp);                        //进行列选择
    
34.                                 Send_Byte(Display_word[0][k]);                        //发送行数据
    - K7 P: j7 X# P8 e
35.                                 LEDARRAY_LAT = 1;                                        //        锁存        
    , K- L/ L, I' ]. t0 D( d9 K' w0 L7 v
36.                                 delay_ms(1);
    
37.                                 LEDARRAY_LAT = 0;
    
38.                               delay_ms(1);
    : ?: B6 j3 O0 K$ C
39.                                 temp = (temp>>1)|0x80;
    7 d, V5 _, x6 i* T
40.             }
    
41.                 }
    3 I* ?6 g  t4 V) E1 B
42.                
    ! g( x3 ?8 ^5 y
43. for(i=0;i<100;i++)
    
44. {
    7 x9 n% y2 [9 ]; P1 E, V
45.                         temp = 0x7f;
    
46.                         for(k = 0 ; k < 8 ; k++)               
    
47.                         {
    
48.                                 Send_Byte(temp);                        
    2 p/ g* M* O1 X' a+ k6 ?; j
49.                                 Send_Byte(Display_word[1][k]);                        
    * c" B8 v6 _- `# w5 e
50.                                 LEDARRAY_LAT = 1;                                       
    % s, R2 W* e- B1 ^( ?
51.                                                 delay_ms(1);
    8 n7 g9 e# a" f+ j/ y- b
52.                                 LEDARRAY_LAT = 0;
    
53.                                                 delay_ms(1);
    
54.                                 temp = (temp>>1)|0x80;
    , O, l  P! u( Z
55.                         }
    # n" }' Q4 {! w) w: V7 M: y& L. Y* r
56.         }
    
57. 
    
58. for(i=0;i<100;i++)
    ( K2 Z# T2 O1 W) L5 X6 `& t
59. {
    
60.                         temp = 0x7f;
    ) X/ X8 ?! `2 w
61.                         for(k = 0 ; k < 8 ; k++)               
    0 D) C3 ]; i% J$ E
62.                         {
    
63.                                 Send_Byte(temp);                        
    ' S/ a; ^/ m2 ~$ _) O
64.                                 Send_Byte(Display_word[2][k]);                        
    
65.                                 LEDARRAY_LAT = 1;                                       
    
66.                                                 delay_ms(1);
    
67.                                 LEDARRAY_LAT = 0;
    
68.                                                 delay_ms(1);
    
69.                                 temp = (temp>>1)|0x80;
    
70.                         }
    
71.         }
    
72. 
    * d# {' ]3 \6 j5 h- M4 _* B( V, U0 L  s
73. for(i=0;i<100;i++)
    
74. {
    
75.                         temp = 0x7f;
    2 l% M, K( \" M8 h1 Q. F1 M9 w
76.                         for(k = 0 ; k < 8 ; k++)               
    $ a$ J% D) D! A
77.                         {
    
78.                                 Send_Byte(temp);                        
    0 ~9 r  F# L& R6 I
79.                                 Send_Byte(Display_word[3][k]);                        
    
80.                                 LEDARRAY_LAT = 1;                                
    ; d) \* Z1 B. x  D
81.                                                 delay_ms(1);
    
82.                                 LEDARRAY_LAT = 0;
    
83.                                                 delay_ms(1);
    
84.                                 temp = (temp>>1)|0x80;
    
85.                         }
    4 O' M0 S8 u' k' l+ O4 j# t
86.         }
    
87. 
    ' ]8 D4 C, U) b
88.         for(i=0;i<100;i++)
    ( _2 B* R6 s9 O5 H$ U; g
89. {
    7 k" z/ w9 s/ j1 [% Z& k
90.                         temp = 0x7f;
    
91.                         for(k = 0 ; k < 8 ; k++)               
    
92.                         {
    
93.                                 Send_Byte(temp);               
    
94.                                 Send_Byte(Display_word[4][k]);                        
    
95.                                 LEDARRAY_LAT = 1;                                       
    
96.                                                 delay_ms(1);
    
97.                                 LEDARRAY_LAT = 0;
    % x4 ^+ ?: Q) t, n/ D/ `! }  f
98.                                                 delay_ms(1);
    % J9 l5 L2 d  F8 z9 ?
99.                                 temp = (temp>>1)|0x80;
    " B4 _" U# @6 u3 N! l+ m
100.                         }
     - N# [$ l: j( r3 O& G# G
101.         }
     
102. 
     
103.         for(i=0;i<100;i++)
     
104. {
     9 R7 ]. I, S1 }( K
105.                         temp = 0x7f;
     & T$ g( S& s& V; J5 o. C
106.                         for(k = 0 ; k < 8 ; k++)               
     8 {- w5 ^9 a2 x% {: Q+ p
107.                         {
     
108.                                 Send_Byte(temp);                        
     ; N" x% h' O5 d1 b' c$ M7 e7 G5 r" v6 R
109.                                 Send_Byte(Display_word[5][k]);                        
     
110.                                 LEDARRAY_LAT = 1;                                       
     
111.                                                 delay_ms(1);
     
112.                                 LEDARRAY_LAT = 0;
     + L% r+ d- n5 U1 U3 C
113.                                                 delay_ms(1);
     5 V- b4 |/ B0 V. W5 d: v# c4 a
114.                                 temp = (temp>>1)|0x80;
     ! [2 x% n" y3 W: x8 f6 Z& y. H2 _
115.                         }
     
116.         }
     
117. 
     2 I/ |' H- A  c1 _; h3 o7 P
118.         for(i=0;i<100;i++)
     
119. {
     ! D& a! @+ I4 X" [5 S: ^
120.                         temp = 0x7f;
     
121.                         for(k = 0 ; k < 8 ; k++)               
     + l- s9 r$ j6 N
122.                         {
     1 {; z- B1 x2 a" j/ o8 q, y
123.                                 Send_Byte(temp);                        
     ' I' F7 P8 E8 t3 C8 F5 x
124.                                 Send_Byte(Display_word[6][k]);                        
     
125.                                 LEDARRAY_LAT = 1;                                       
     
126.                                                 delay_ms(1);
     9 H' y" F+ s- j1 K
127.                                 LEDARRAY_LAT = 0;
     
128.                                                 delay_ms(1);
     2 W  [4 d6 N- V
129.                                 temp = (temp>>1)|0x80;
     
130.                         }
     7 P+ @; `4 r$ {* g5 `- Z* V: @2 i3 u# ~2 V
131.         }
     / i0 r; {' m8 j
132. 
     
133.         
     
134. }
     - s& H; [7 q' K+ o4 L' J8 e
135. }

复制代码

+ @) X! r- b: Q2 b/ c具体代码解释也在上面讲了，希望能对大家有所帮助
0 c: k$ B9 J+ ?/ `: V
8 ^* F) l, l8 ]8 Z  ~三、取模方法
2 U1 |& ^5 O, ?9 g首先你得有个取模软件，上上上讲MSP430F5529之1.44寸OLED显示（附源码）_ZJ Sky的博客-CSDN博客     我就给大家附上了文字取模和图片取模软件了，大家如果没有可以到上面链接里面下载，好了接下来详细讲一下怎么用

第一步：点开软件后，左上角新建
+ w% j8 d& b% F( R, g


9 Z- k# E4 ?8 y6 ?9 o第二步：弹出这个窗口，输入8*8
* M& H" i, E& P0 _0 y* }; r" @2 C

% B* {8 U  [, s2 {# Y. h5 s
  r6 B+ {! X9 S8 S* I. i- h9 s6 B 第三步：打开设置


  E7 b* @+ t  n1 S
第四步：设置参数（可以自己设置各种方式，但是要统一）


$ p  R4 c) G4 @
, c8 q* r: S1 W3 L: F! U. N6 N0 ?. ^! u- M+ _第五步：自己画图，然后生成代码，搬到自己的工程中去就行

/ \: C2 \( ~5 j2 S
$ i$ Y% W0 k  u
四、总结
快乐时光总是短暂的，学**是永无止境的，到这里基本上已经把该讲的都讲的差不多了，剩下的就靠你自己剖析了，多试试，不试试怎么知道自己做不做的到，马上去上手8*8点阵模块的使用了吧，

7 I! v9 d$ `3 ^0 P! m$ P  U