光电计数和蓝牙控制RGB的程序问题，急急急！！！

我要写一个蓝牙控制RGB变色和两个光电传感器计数的程序
单个的模块可以实现，但是我在往一起合的时候，就不能了
而且发现功能会互相影响，求大神帮我改一下代码，说一下
思路，怎么才能两个同时运行，，很急..

1.         #include <reg52.h>
   
2.         #include <string.h>
   
3.         #include <intrins.h>
   
4.         
   
5.         #define LCD1602_DB  P0
   
6.         
   
7.         unsigned char tmp;
   
8.         unsigned int c=0;
   
9.         unsigned char flag1s = 0;
   
10.         unsigned char flag2s = 0;
    
11.         unsigned char counter = 0;//jishu
    
12.         unsigned char str[] = "COUNT: ";
    
13.         sbit LCD1602_RS = P1^0;
    
14.         sbit LCD1602_RW = P1^1;
    
15.         sbit LCD1602_E = P1^5;
    
16.         
    
17.         sbit red   = P2^0;
    
18.         sbit LED = P2^2;                                                                                                        
    
19.         sbit red1 = P2^1;
    
20.         
    
21.         sbit RR = P3^5;
    
22.         sbit GG = P3^6;
    
23.         sbit BB = P3^7;
    
24.         
    
25.          int PWM_0 = 0;
    
26.          int PWM_1 = 0;
    
27.          int PWM_2 = 0;
    
28.         
    
29.         void InitLcd1602();
    
30.         void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str);
    
31.         void itoa (unsigned int n,unsigned char s[5]);
    
32.         void keepred();
    
33.         
    
34.         void init();   //串口初始化
    
35.         void send(unsigned char a);        //单字节发送函数
    
36.         void ctrl(); //接收处理函数
    
37.         void color();
    
38.         void keepPWM();
    
39.         
    
40.         void delay (unsigned char t) //延时
    
41.         {
    
42.             unsigned char i;
    
43.             while(t--)
    
44.             {
    
45.                 for(i=0; i<114; i++);
    
46.             }
    
47.         }
    
48.         
    
49.         void main()
    
50.         {
    
51.                 unsigned int sec = 0, i=0, j = 0;        
    
52.         
    
53.                 unsigned char s[5] ;
    
54.                 unsigned char x[6] = "none";
    
55.                 init();        
    
56.             red = 1;
    
57.                 red1 = 1;
    
58.                 TMOD = 0x21;
    
59.                 TL0 = 0xC9;                //设置定时初值
    
60.                 TH0 = 0xFF;               
    
61.                 TR0 = 1;               
    
62.                 ET0 = 1;
    
63.                 ET1 = 1;
    
64.                 EA = 1;
    
65.                 InitLcd1602();
    
66.                
    
67.                 sec = 0;
    
68.                 itoa(sec, s);
    
69.                 LcdShowStr(8, 0, x);
    
70.                 while(1)
    
71.                 {        
    
72.                         keepPWM();
    
73.                         if(RI==1)                     // 是否有数据到来
    
74.                       {   
    
75.                  RI = 0;
    
76.                  tmp = SBUF;
    
77.                          ctrl();
    
78.                           delay(5);                   // 暂存接收到的数据  
    
79.                      }
    
80.                                     
    
81.                         else if(flag1s == 1 )                  
    
82.                         {               
    
83.                                 flag1s = 0;                        
    
84.                                 sec++;        
    
85.                         }
    
86.                         else if(flag2s == 1 )                  
    
87.                         {               
    
88.                             flag2s = 0;        
    
89.                                 if(sec > 0)
    
90.                                  sec--;
    
91.                         }
    
92.                         else if(sec<=0)
    
93.                         {
    
94.                         sec = 0;
    
95.                         
    
96.                         LcdShowStr(8, 0, x);
    
97.                         }
    
98.                          else
    
99.                         {
    
100.                         
     
101.                         itoa(sec, s);
     
102.                         memset(s, '\0', 5);
     
103.                         delay(50);
     
104.                         
     
105.                         }
     
106.                         if(RI == 0)
     
107.                         {
     
108.                                 PWM_0 = PWM_0;
     
109.                                 PWM_1 = PWM_1;
     
110.                                 PWM_2 = PWM_2;
     
111.                                 delay(5);
     
112.                         }
     
113.                         delay(5);                                
     
114.                 }               
     
115.         }
     
116. 
     
117.         void LcdWaitReady()
     
118.         {
     
119.                 unsigned char sta;
     
120.         
     
121.                 LCD1602_DB = 0xFF;
     
122.                 LCD1602_RS = 0;
     
123.                 LCD1602_RW = 1;
     
124.                 do        {
     
125.                         LCD1602_E = 1;
     
126.                         sta = LCD1602_DB;
     
127.                         LCD1602_E = 0;
     
128.                 }while(sta & 0x80);
     
129.         }
     
130.         void LcdWriteCmd(unsigned char cmd)
     
131.         {
     
132.                 LcdWaitReady();
     
133.                 LCD1602_RS = 0;
     
134.                 LCD1602_RW = 0;
     
135.                 LCD1602_DB = cmd;
     
136.                 LCD1602_E = 1;
     
137.                 LCD1602_E = 0;
     
138.         }
     
139.         void LcdWriteDat(unsigned char dat)
     
140.         {
     
141.                 LcdWaitReady();
     
142.                 LCD1602_RS = 1;
     
143.                 LCD1602_RW = 0;
     
144.                 LCD1602_DB = dat;
     
145.                 LCD1602_E = 1;
     
146.                 LCD1602_E = 0;
     
147.         }
     
148.         void LcdSetCursor(unsigned char x, unsigned char y)
     
149.         {
     
150.                 unsigned char addr;
     
151.                 if(y == 0)
     
152.                         addr = 0x00 + x;
     
153.                 else
     
154.                         addr = 0x40 + x;
     
155.                 LcdWriteCmd(addr | 0x80);
     
156.         }
     
157.         void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str)
     
158.         {
     
159.                 LcdSetCursor(x, y);
     
160.                 while(*str != '\0')
     
161.                 {
     
162.                         LcdWriteDat(*str++);   
     
163.                 }
     
164.         }
     
165.         void InitLcd1602()
     
166.         {
     
167.                 LcdWriteCmd(0x38);
     
168.                 LcdWriteCmd(0x0C);
     
169.                 LcdWriteCmd(0x06);
     
170.                 LcdWriteCmd(0x01);
     
171.         }
     
172.         void itoa (unsigned int n,unsigned char s[])
     
173.         {
     
174.             unsigned char temp;
     
175.             unsigned int i = 0;
     
176.             unsigned int len = 0;            
     
177.             while(n != 0)
     
178.             {
     
179.                 s[i] = (n  % 10) + '0' ;//算出字符
     
180.                 n = n / 10;
     
181.                        i++;
     
182.             }
     
183.             s[i] = '\0';
     
184.             len = strlen(s);
     
185.             for(i = 0; i < len / 2; i++) //前后换顺序
     
186.             {
     
187.                 temp = s[i];
     
188.                 s[i] = s[len - 1 - i];
     
189.                 s[len - 1 - i] = temp;
     
190.             }
     
191.                 LcdShowStr(1, 0, str);
     
192.                 LcdWriteCmd(0x01);
     
193.                 LcdShowStr(1, 0, str);
     
194.                 LcdShowStr(8, 0, s);
     
195.                 s[0] = '\0';
     
196.         }
     
197.         void keepPWM()//保持输出
     
198.         {
     
199.                         if(PWM_0 <=0)
     
200.                         PWM_0 =0;
     
201.                         if(PWM_1 <=0)
     
202.                         PWM_1 =0;
     
203.                         if(PWM_2 <=0)
     
204.                         PWM_2 =0;
     
205.                         if(PWM_0 >=255)
     
206.                         PWM_0 =255;
     
207.                         if(PWM_1 >=255)
     
208.                         PWM_1 =255;
     
209.                         if(PWM_2 >=255)
     
210.                         PWM_2 =255;
     
211.         }
     
212.         void init()        //串口初始化
     
213.         {
     
214.             ES=0;                                                                  //关中断
     
215.             SCON = 0x50;                        // REN=1允许串行接受状态，串口工作模式1,
     
216.             //10位UART（1位起始位，8位数据位，1位停止位，无奇偶校验），波特率可变
     
217.         
     
218.             TMOD = 0x20;                        // 定时器1工作于方式2，8位自动重载模式, 用于产生波特率
     
219.             TH1=TL1=0xFD;                       // 波特率9600 （本次测试采用晶振为11.0592）
     
220.         
     
221.             PCON &= 0x7f;                       // 波特率不倍增
     
222.             TR1 = 1;                                                          //定时器1开始工作，产生波特率
     
223.             //发送标志位置0
     
224.             TI=0;                                                                  //接收标志位置0
     
225.             RI=0;
     
226.             //EA=0;
     
227.            ES=1;
     
228.         }
     
229.         
     
230.         /*void send(unsigned char a)        //单字节数据发送
     
231.         {
     
232.             //注意：若单片机TXD（P3.1）无上拉能力，必须在P3.1端接上拉电阻。本次测试需要接上拉电阻
     
233.             TI=0;
     
234.             SBUF=a;
     
235.             while(TI==0);
     
236.             TI=0;
     
237.             if(c%2)                                        //发送指示灯标志，每接收一次，此灯亮灭交替
     
238.                 led=1;
     
239.             else
     
240.                 led=0;
     
241.             c++;
     
242.         }*/
     
243.         
     
244.         void ctrl()                            //接收处理函数
     
245.         {
     
246.                    switch(tmp)
     
247.                     {
     
248.                     case '1':           //白
     
249.                 PWM_0 = 0;
     
250.                         PWM_1 = 0;
     
251.                         PWM_2 = 0;  
     
252.                         LED = ~LED;
     
253.                 break;
     
254.                     case '2':                                       
     
255.                 PWM_0 = 255-128;        //紫
     
256.                         PWM_1 = 255;
     
257.                         PWM_2 = 255-128;
     
258.                         LED = ~LED;
     
259.                 break;
     
260.                            case '3':                                   
     
261.                 PWM_0 = 255;        //蓝色
     
262.                         PWM_1 = 255;
     
263.                         PWM_2 = 0;
     
264.                         LED = ~LED;
     
265.                 break;
     
266.                     case '4':                                       
     
267.                 PWM_0 = 30;        // 浅蓝
     
268.                         PWM_1 = 100;
     
269.                         PWM_2 = 255;
     
270.                         LED = ~LED;
     
271.                 break;
     
272.                     case '5':                                       
     
273.                 PWM_0 = 255-33;        //        灰
     
274.                         PWM_1 = 255-33;
     
275.                         PWM_2 = 255-33;
     
276.                         LED = ~LED;
     
277.                 break;
     
278.                         case '6':                                       
     
279.                 PWM_0 = 254;        //        mie
     
280.                         PWM_1 = 254;
     
281.                         PWM_2 = 254;
     
282.                         LED = ~LED;
     
283.                 break;
     
284.                         case 'a':
     
285.                         PWM_0=PWM_0+5;        //        jiaqiang
     
286.                         PWM_1=PWM_1+5;
     
287.                         PWM_2=PWM_2+5;
     
288.                         break;
     
289.                         case 'b':
     
290.                         PWM_0=PWM_0-5;        //  jianruo
     
291.                         PWM_1=PWM_1-5;
     
292.                         PWM_2=PWM_2-5;
     
293.                         keepPWM();
     
294.                         break;
     
295.                         case 'c':           //shanshuo
     
296.                         
     
297.                         color();
     
298.                         LED = ~LED;
     
299.                         break;
     
300.                     default:                   //其他，灯全灭
     
301.                 PWM_0 = 0;        //hei
     
302.                         PWM_1 = 0;
     
303.                         PWM_2 = 0;
     
304.                // send(tmp);
     
305.                    break;
     
306.                    }delay(5);        
     
307.         }
     
308.         void color()
     
309.         {                                                           //随机颜色
     
310.              while(RI==0)
     
311.                 {
     
312.                 PWM_0 = rand()%255;
     
313.                 delay(2);
     
314.                 PWM_1 = rand()%255;
     
315.                 delay(2);
     
316.                 PWM_2 = rand()%255;
     
317.                 delay(2);
     
318.                 }
     
319.         }
     
320.         
     
321.         void InterruptTimer0() interrupt 1
     
322.         {
     
323.             TH0 = 0xFC;
     
324.                 TL0 = 0x67;
     
325.                
     
326.            if (red == 0&&red1==1)                             //两个光电判断人进出
     
327.             {
     
328.                 delay(99);
     
329.                         if(red1==0)
     
330.                 flag1s = 1;
     
331.             }
     
332.             if (red1 == 0&&red == 1)  
     
333.             {
     
334.                 delay(99);
     
335.                         if(red == 0)
     
336.                flag2s = 1;
     
337.             }
     
338.                
     
339.                 counter++;
     
340.                         if(counter >= 255) counter = 0;                                   //三路pWM输出
     
341.                     if(counter >= PWM_0) RR = 0; else RR = 1;
     
342.                     if(counter >= PWM_1) GG = 0; else GG = 1;
     
343.                     if(counter >= PWM_2) BB = 0; else BB = 1;        
     
344.         }

复制代码