单片机C语言怎么让数码管移位显示?

现在数码管最初状态全为0，我想一开始不显示，按下矩阵按钮显示对应的数，然后再按下矩阵按键前一个数左移后面显示新的数字，需要如何改进。
单片机C语言源程序如下:

1. #include"reg51.h"
   
2. typedef unsigned char u8;        
   
3. typedef unsigned int u16;
   
4. 
   
5. sbit LSA=P2^2;  
   
6. sbit LSB=P2^3;
   
7. sbit LSC=P2^4;
   
8. 
   
9. #define GPIO_KEY P1
   
10. #define GPIO_DIG P0
    
11. u16 a,b,c;
    
12. u16 KeyValue;        
    
13. u16 keyflag,i;      
    
14. u8 code smgduan[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07, 0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x40};
    
15. u8 dat[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07, 0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x40};
    
16. u16 wei[8]={0};   
    
17. 
    
18. void delay(u16 i)
    
19. {  
    
20.      while(i--);
    
21. }
    
22. 
    
23. void display()   
    
24. {   
    
25.      LSA=0; LSB=0; LSC=0; GPIO_DIG=smgduan[wei[0]];delay(50); GPIO_DIG=0x00;
    
26.      LSA=1; LSB=0; LSC=0; GPIO_DIG=smgduan[wei[1]];delay(50); GPIO_DIG=0x00;
    
27.      LSA=0; LSB=1; LSC=0; GPIO_DIG=smgduan[wei[2]];delay(50); GPIO_DIG=0x00;
    
28.      LSA=1; LSB=1; LSC=0; GPIO_DIG=smgduan[wei[3]];delay(50); GPIO_DIG=0x00;
    
29.      LSA=0; LSB=0; LSC=1; GPIO_DIG=smgduan[wei[4]];delay(50); GPIO_DIG=0x00;
    
30.      LSA=1; LSB=0; LSC=1; GPIO_DIG=smgduan[wei[5]];delay(50); GPIO_DIG=0x00;
    
31.      LSA=0; LSB=1; LSC=1; GPIO_DIG=smgduan[wei[6]];delay(50); GPIO_DIG=0x00;
    
32.      LSA=1; LSB=1; LSC=1; GPIO_DIG=smgduan[wei[7]];delay(50); GPIO_DIG=0x00;
    
33. }
    
34. void KeyDown(void)
    
35. {
    
36.     u16 a=0;
    
37.     GPIO_KEY=0x0f;
    
38.     if(GPIO_KEY!=0x0f)
    
39.     {
    
40.         delay(1000);
    
41.         if(GPIO_KEY!=0x0f)
    
42.         {   
    
43.             GPIO_KEY=0x0f;
    
44.             switch(GPIO_KEY)
    
45.             {
    
46.                 case(0X07): KeyValue=9;break;
    
47.                 case(0X0b): KeyValue=8;break;
    
48.                 case(0X0d): KeyValue=7;break;
    
49.                 case(0X0e): KeyValue=20;break;
    
50.             }
    
51.             GPIO_KEY=0xf0;
    
52.             switch(GPIO_KEY)
    
53.             {
    
54.                 case(0X70): KeyValue=KeyValue;break;
    
55.                 case(0Xb0): KeyValue=KeyValue-3;break;
    
56.                 case(0Xd0): KeyValue=KeyValue-6;break;
    
57.                 case(0Xe0): KeyValue=KeyValue-9;break;
    
58.             }
    
59.                                                 
    
60.             if(KeyValue==0 || KeyValue==1 || KeyValue==2 || KeyValue==3 || KeyValue==4 || KeyValue==5 || KeyValue==6 || KeyValue==7 || KeyValue==8 || KeyValue==9)
    
61.             {
    
62.                keyflag=1;
    
63.             }
    
64.              while((a<50)&&(GPIO_KEY!=0xf0))
    
65.             {
    
66.                 delay(1000);
    
67.                 a++;
    
68.             }
    
69.         }
    
70.     }
    
71. }
    
72. void main()
    
73. {  
    
74.    u16 a=0,b=0,c=0;
    
75. 
    
76.    while(1)
    
77.    {   
    
78.          display();                  
    
79.          KeyDown();               
    
80.          if(keyflag==1)  
    
81.          {                                 
    
82.             for(i=7;i>0;i--)            
    
83.             {
    
84.                                                    wei[i]=wei[i-1];
    
85.                                                 }            
    
86.             wei[0]=KeyValue;                           
    
87.             keyflag=0;                                 
    
88.          }
    
89. 
    
90.          else if(KeyValue==-1)
    
91.          {
    
92.               for(i=0;i<8;i++)
    
93.               wei[i]=0;              
    
94.               display();
    
95.         }
    
96. 
    
97.         else if(KeyValue==20)     
    
98.          {
    
99.              a=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;   
    
100.              for(i=0;i<8;i++)
     
101.              wei[i]=0;
     
102.              while(1)                                
     
103.              {
     
104.                      display();
     
105.                      KeyDown();
     
106.                      if(KeyValue==-2) break;
     
107.                      if(keyflag==1)
     
108.                      {  
     
109.                         for(i=7;i>0;i--)
     
110.                         {wei[i]=wei[i-1];}
     
111.                         wei[0]=KeyValue;
     
112.                         keyflag=0;
     
113.                      }
     
114.               }
     
115.               b=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;   
     
116.              c=a+b;
     
117.              wei[0]=c%10;                  
     
118.              wei[1]=c/10%10;
     
119.              wei[2]=c/100%10;
     
120.              wei[3]=c/1000%10;
     
121.              wei[4]=c/10000%10;
     
122.              wei[5]=c/100000%10;
     
123.              wei[6]=c/1000000%10;
     
124.              wei[7]=c/10000000%10;
     
125. 
     
126.              display();
     
127.         }
     
128. 
     
129.         else    if(KeyValue==17)      
     
130.          {
     
131.              a=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;
     
132.              for(i=0;i<8;i++)
     
133.              wei[i]=0;
     
134.              while(1)
     
135.              {                                    
     
136.                      display();
     
137.                      KeyDown();
     
138.                      if(KeyValue==-2) break;
     
139.                      if(keyflag==1)
     
140.                      {  
     
141.                         for(i=7;i>0;i--)
     
142.                         {wei[i]=wei[i-1];}
     
143.                         wei[0]=KeyValue;
     
144.                         keyflag=0;
     
145.                      }
     
146.              }
     
147.              b=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;   
     
148.              if(a>=b)
     
149.              {
     
150.                c=a-b;
     
151.                wei[0]=c%10;                 
     
152.                wei[1]=c/10%10;
     
153.                wei[2]=c/100%10;
     
154.                wei[3]=c/1000%10;
     
155.                wei[4]=c/10000%10;
     
156.                wei[5]=c/100000%10;
     
157.                wei[6]=c/1000000%10;
     
158.                wei[7]=c/10000000%10;
     
159.              }
     
160.              if(a<b)
     
161.              {
     
162.                  u16 e=0;
     
163.                  c=b-a;
     
164.                 wei[0]=c%10;              
     
165.                 wei[1]=c/10%10;
     
166.                 if(wei[1]==0)
     
167.                {
     
168.                 wei[1]=16;
     
169.                 e=1;
     
170.                }
     
171.                wei[2]=c/100%10;
     
172.                if(wei[2]==0 && e==0)
     
173.                 {
     
174.                    wei[2]=16;
     
175.                     e=1;
     
176.                  }
     
177.                  wei[3]=c/1000%10;
     
178.                     if(wei[3]==0 && e==0)
     
179.                     {
     
180.                      wei[3]=16;
     
181.                      e=1;
     
182.                     }
     
183.                                 wei[4]=c/10000%10;
     
184.                     if(wei[4]==0 && e==0)
     
185.                     {
     
186.                      wei[4]=16;
     
187.                      e=1;
     
188.                     }
     
189.                      wei[5]=c/100000%10;
     
190.                    if(wei[5]==0 && e==0)
     
191.                    {
     
192.                          wei[5]=16;
     
193.                          e=1;
     
194.                    }
     
195.                    wei[6]=c/1000000%10;
     
196.                     if(wei[6]==0 && e==0)
     
197.                     {
     
198.                      wei[6]=16;
     
199.                      e=1;
     
200.                     }
     
201.                      wei[7]=c/10000000%10;
     
202.                     if(wei[7]==0 && e==0)
     
203.                     {
     
204.                      wei[7]=16;
     
205.                      e=1;
     
206.                     }
     
207.                  }
     
208.                  display();
     
209.            }
     
210. 
     
211.           else   if(KeyValue==14)     
     
212.          {
     
213.              a=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;
     
214.              for(i=0;i<8;i++)
     
215.              wei[i]=0;
     
216.              while(1)
     
217.              {                                      
     
218.                      display();
     
219.                      KeyDown();
     
220.                      if(KeyValue==-2) break;
     
221.                      if(keyflag==1)
     
222.                      {  
     
223.                         for(i=7;i>0;i--)
     
224.                         {wei[i]=wei[i-1];}
     
225.                         wei[0]=KeyValue;
     
226.                         keyflag=0;
     
227.                      }
     
228.               }
     
229.               b=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;   
     
230.              c=a*b;
     
231.              wei[0]=c%10;                 
     
232.              wei[1]=c/10%10;
     
233.              wei[2]=c/100%10;
     
234.              wei[3]=c/1000%10;
     
235.              wei[4]=c/10000%10;
     
236.              wei[5]=c/100000%10;
     
237.              wei[6]=c/1000000%10;
     
238.              wei[7]=c/10000000%10;
     
239.              display();
     
240.          }
     
241. 
     
242.          else  if(KeyValue==11)      
     
243.          {
     
244.              a=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;
     
245.              for(i=0;i<8;i++)
     
246.              wei[i]=0;
     
247.              while(1)                                 
     
248.              {
     
249.                      display();
     
250.                      KeyDown();
     
251.                      if(KeyValue==-2) break;
     
252.                      if(keyflag==1)
     
253.                      {  
     
254.                         for(i=7;i>0;i--)
     
255.                         {wei[i]=wei[i-1];}
     
256.                         wei[0]=KeyValue;
     
257.                         keyflag=0;
     
258.                      }
     
259.               }
     
260.               b=wei[0]+wei[1]*10+wei[2]*100+wei[3]*1000+wei[4]*10000+wei[5]*100000+wei[6]*1000000+wei[7]*10000000;   
     
261.              c=a/b;
     
262.              wei[0]=c%10;                  
     
263.              wei[1]=c/10%10;
     
264.              wei[2]=c/100%10;
     
265.              wei[3]=c/1000%10;
     
266.              wei[4]=c/10000%10;
     
267.              wei[5]=c/100000%10;
     
268.              wei[6]=c/1000000%10;
     
269.              wei[7]=c/10000000%10;
     
270.              display();               
     
271.          }
     
272.      }
     
273. }
     

复制代码

建议看一下有关数码管显示方面的内容，掌握方法了，想怎么显示、怎么移动都可以

建一个数组用于数码管显示，比如4位数码管就【4】{；；；} i++

不用写这么复杂，改这样就能达目的。

1. #include"reg51.h"
   
2. typedef unsigned char u8;        
   
3. typedef unsigned int u16;
   
4. //sbit LSA=P2^2;  
   
5. //sbit LSB=P2^3;
   
6. //sbit LSC=P2^4;
   
7. //#define GPIO_KEY P1
   
8. //#define GPIO_DIG P0
   
9. //u16 a,b,c;
   
10. u8 KeyValue;        
    
11. //u16 keyflag,i;      
    
12. u8 code smgduan[]={//共阴数码管段码"0~f-."
    
13.                 0x3f,0x06,0x5b,0x4f,
    
14.                 0x66,0x6d,0x7d,0x07,
    
15.                 0x7f,0x6f,0x77,0x7c,
    
16.                 0x39,0x5e,0x79,0x71,0x40,0x80};
    
17. u8 dat[9];
    
18. //u16 wei[8]={0};   
    
19. 
    
20. void delay(u16 i)
    
21. {  
    
22.      while(i--);
    
23. }
    
24. 
    
25. void KeyDown(void)
    
26. {
    
27.         static bit sign=0;
    
28.         static u8 count=0;
    
29.         u8 i;
    
30.         P1=0xf0;       
    
31.         if(P1!=0xf0)
    
32.         {
    
33.                 if(++count>=10 && sign==0)
    
34.                 {                       
    
35.                         sign=1;
    
36.                         switch(P1)
    
37.                         {
    
38.                                 case(0Xe0):KeyValue = 0;break;
    
39.                                 case(0Xd0):KeyValue = 1;break;
    
40.                                 case(0Xb0):KeyValue = 2;break;
    
41.                                 case(0X70):KeyValue = 3;break;
    
42.                         }
    
43.                         P1=0x0f;
    
44.                         switch(P1)
    
45.                         {
    
46.                                 case(0X0e):KeyValue+= 0;break;
    
47.                                 case(0X0d):KeyValue+= 4;break;
    
48.                                 case(0X0b):KeyValue+= 8;break;
    
49.                                 case(0X07):KeyValue+=12;break;
    
50.                         }
    
51.                         dat[8]=smgduan[KeyValue];
    
52.                         for(i=0;i<8;i++)
    
53.                                 dat[i]=dat[i+1];
    
54.                 }
    
55.         }
    
56.         else
    
57.         {
    
58.                 sign=0;
    
59.                 count=0;
    
60.         }
    
61. }
    
62. 
    
63. void display()   
    
64. {   
    
65.         static u8 i=0;
    
66.         P0=0x00;
    
67.         P2&=0xe3;
    
68.         P2|=(i*4);
    
69.         P0=dat[i];
    
70.         i=++i%8;
    
71. }
    
72. 
    
73. void main()
    
74. {  
    
75.    while(1)
    
76.    {   
    
77.                 KeyDown();
    
78.                 display();
    
79.                 delay(100);
    
80.         }
    
81. }
    

复制代码