各位大神，我这个步进电机定义的是2.5周，可以运行起来要4周。烦请各位给指点一二。多谢了。

1. /***************************************
   
2.   用4X4矩阵键盘进行步进电机操作
   
3. ***************************************/
   
4. 
   
5. #include <reg52.h>
   
6. 
   
7. #define uchar unsigned char
   
8. #define uint unsigned int
   
9. long g_Beats = 0;
   
10. 
    
11. void DelayMs(uint ms);                                   //延时函数声明；
    
12. uchar KeyPress(void);                                   //按键按下检测函数声明；
    
13. uchar KeyScan(void);                                   //键值扫描函数声明；
    
14. void OffMotor(void);
    
15. void TurnAngle(long angle);
    
16. void OnMotor(void);
    
17. void OffMotor(void);
    
18. void KeyCode(uchar keycode);
    
19. void Timer0Init(void);
    
20. 
    
21. void main(void)
    
22. {
    
23.         Timer0Init();
    
24.         while (1)
    
25.         {
    
26.                 if (KeyPress())
    
27.                 {
    
28.                         KeyCode(KeyScan());
    
29.                 }
    
30.         }
    
31. }
    
32. //定时器0初始化函数
    
33. void Timer0Init(void)
    
34. {
    
35.         TMOD |= 0x01;
    
36.         TH0 = 0xFC;
    
37.         TL0 = 0x66;
    
38.         EA = 1;
    
39.         ET0 = 1;
    
40.         TR0 = 1;
    
41. }
    
42. //延时函数
    
43. void DelayMs(uint ms)                                //11.0592MHZ 约为1.007MS;
    
44. {
    
45.         uint x,y;
    
46.         for(x=ms;x>0;x--)                                                 
    
47.         {
    
48.                 for(y=113;y>0;y--);
    
49.         }
    
50. }
    
51. //按键是否按下检测函数
    
52. uchar KeyPress(void)
    
53. {
    
54.         uchar readnum;
    
55.         P1 = 0xF0;                                //P1口的高四位作为输入，则需要对高四位进行初始化；                          
    
56.         readnum = P1;                        //将端口的状态赋值给一个变量，这样必免直接操作端口时，影响到端口的状态；
    
57.         if (readnum == 0xF0)
    
58.         {
    
59.                 return 0;
    
60.         }
    
61.         else
    
62.         {
    
63.                 return 1;
    
64.         }
    
65. }
    
66. //按键扫描函数
    
67. uchar KeyScan(void)
    
68. {
    
69.         uchar index,keycode,keyvalue;
    
70.         DelayMs(20);                                  //延时20MS;
    
71.         P1 = 0xFF;                                          //定义键盘的输出状态初始值
    
72.         index = 0;                                          //输出行索引；
    
73.         if (KeyPress())                                  //再次判断按键按下
    
74.         {
    
75.                 while (1)
    
76.                 {
    
77.                         P1 = (0xF7 >> index) | 0xF0; //I/O端口不能做为中间变量，如temp = (P1 >> index) 单片机随时读取IO的变化，会导致程序有瞬间错误产生；
    
78.                         index++;                                         
    
79.                         index = index & 0x03;                     //要扫描四行中哪一行为输出低电平，当index == 4时，index清零；
    
80.                         keycode = P1;                                         //当按键按下时，P1端口的高四位为高，若扫描到四行中某一行为0时，此时按键已经按下，P1口的高四位的其中一位将被低四位为0的一行拉低，这样键值就出来了。
    
81.                         if ((keycode & 0xF0) ！= 0xF0)         //如果按键在按下状态，获得键值停止扫描
    
82.                         {
    
83.                                 break;                                             //获得键码，跳出扫描；
    
84.                         }
    
85.                        
    
86.                 }
    
87.                 switch (keycode)
    
88.                 {
    
89.                         case 0x77 : keyvalue = 0x31;     break;
    
90.                         case 0x7B : keyvalue = 0x37;     break;
    
91.                         case 0x7D : keyvalue = 0x34;     break;
    
92.                         case 0x7E : keyvalue = 0x30;     break;
    
93.                        
    
94.                         case 0xB7 : keyvalue = 0x1B;     break;
    
95.                         case 0xBB : keyvalue = 0x38;     break;
    
96.                         case 0xBD : keyvalue = 0x35;     break;
    
97.                         case 0xBE : keyvalue = 0x32;     break;
    
98. 
    
99.                         case 0xD7 : keyvalue = 0x0D;     break;
    
100.                         case 0xDB : keyvalue = 0x39;     break;
     
101.                         case 0xDD : keyvalue = 0x36;     break;
     
102.                         case 0xDE : keyvalue = 0x33;     break;
     
103.                        
     
104.                         case 0xE7 : keyvalue = 0x27;     break;
     
105.                         case 0xEB : keyvalue = 0x25;     break;
     
106.                         case 0xED : keyvalue = 0x28;     break;
     
107.                         case 0xEE : keyvalue = 0x26;     break;
     
108.                         default : keyvalue = 0xFF;
     
109.                         while (KeyPress());                  //等待按键释放
     
110.                 }
     
111.         }
     
112.         else
     
113.         {
     
114.                 keyvalue = 0xFF;                                                                        //如果没有按键按下时，键值为关闭
     
115.         }
     
116.         return keyvalue;                                                                                //返回键值；
     
117. }
     
118. //获取键值函数，
     
119. void KeyCode(uchar keycode)
     
120. {
     
121.          static bit direc = 0;
     
122.          if ((keycode >= 0x30) && (keycode <=0x39))
     
123.          {
     
124.                  if (direc == 0)
     
125.                 {
     
126.                         TurnAngle(360 * (keycode - 0x30));
     
127.                 }
     
128.                 else
     
129.                 {
     
130.                         TurnAngle(-360 * (keycode - 0x30));
     
131.                 }
     
132.          }
     
133.          else if (keycode == 0x26)
     
134.          {
     
135.                  direc = 0;
     
136.          }
     
137.          else if (keycode == 0x28)
     
138.          {
     
139.                  direc = 1;
     
140.          }
     
141.          else if (keycode == 0x25)
     
142.          {
     
143.                  TurnAngle(90);
     
144.          }
     
145.          else if (keycode == 0x27)
     
146.          {
     
147.                  TurnAngle(-90);
     
148.          }
     
149.          else if (keycode == 0x1B)
     
150.          {
     
151.                  OffMotor();
     
152.          }
     
153. }
     
154. //旋转角度函数
     
155. void TurnAngle(long angle)
     
156. {
     
157.         EA = 0;
     
158.         g_Beats = (angle * 4076) / 360;
     
159.         EA = 1;
     
160. }
     
161. //关闭步进电机函数
     
162. void OffMotor(void)
     
163. {
     
164.         EA = 0;
     
165.         g_Beats = 0;
     
166.         EA = 1;       
     
167. }
     
168. //定时器0中断函数
     
169. void Timer0IRQ() interrupt 1                                                 //中断函数不需要声明
     
170. {
     
171.         TH0 = 0xFC;
     
172.         TL0 = 0x66;
     
173.         OnMotor();
     
174. }
     
175. //开启步进电机函数
     
176. void OnMotor()
     
177. {
     
178.         uchar temp;
     
179.         static uchar subscript =0;
     
180.         uchar code BeatCode[] = {0x0E,0x0C,0x0D,0x09,
     
181.                                                           0x0B,0x03,0x07,0x06};
     
182.     //P0 = 0xFF;
     
183.        
     
184.         if (g_Beats ！= 0)
     
185.         {
     
186.                 if (g_Beats > 0)
     
187.                 {
     
188.                    subscript++;
     
189.                    subscript &= 0x07;
     
190.                    g_Beats--;
     
191.                 }
     
192.                 else
     
193.                 {
     
194.                    subscript--;
     
195.                    subscript &= 0x07;
     
196.                    g_Beats++;
     
197.                 }
     
198.                 temp = P0;
     
199.                 temp = temp & 0xF0;
     
200.                 P0 = temp | BeatCode[subscript];
     
201.         }
     
202.         else
     
203.         {
     
204.                 P0 |= 0x0F;
     
205.         }       
     
206. }

搞程序是要报酬的

报酬可以，你说个价。