单片机货车超重检车程序

C语言程序

1. #include <AT89X52.h>
   
2. #include <intrins.h>
   
3. #include <stdio.h>
   
4. 
   
5. 
   
6. #define R24C04ADD 0xA1
   
7. #define W24C04ADD 0xA0
   
8. 
   
9. //ADC0832的引脚
   
10. sbit ADCS =P2^2;  //ADC0832 chip seclect
    
11. sbit ADDI =P2^4;  //ADC0832 k in
    
12. sbit ADDO =P2^4;  //ADC0832 k out
    
13. sbit ADCLK =P2^3;  //ADC0832 clock signal
    
14. 
    
15. 
    
16. sbit SDA = P2 ^ 1;                                //数据线
    
17. sbit SCL = P2 ^ 0;                                //时钟线
    
18. bit bAck;                                          //应答标志 当bbAck=1是为正确的应答
    
19. 
    
20. unsigned char dispbitcode[8]={0xf7,0xfb,0xfd,0xfe,0xef,0xdf,0xbf,0x7f};  //位扫描
    
21. unsigned char dispcode[11]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xff};  //共阳数码管字段码
    
22. unsigned char dispbuf[4];
    
23. unsigned int temp;
    
24. unsigned char getdata; //获取ADC转换回来的值
    
25. 
    
26. 
    
27. void delay_1ms(void)  //12mhz delay 1.01ms
    
28. {
    
29.    unsigned char x,y;   
    
30.    x=3;
    
31.    while(x--)
    
32.   {
    
33.        y=40;
    
34.        while(y--);
    
35.     }
    
36. }
    
37. void display(void)  //数码管显示函数
    
38. {
    
39.   char k;
    
40.   for(k=0;k<4;k++)
    
41.   {
    
42. 
    
43.   P1 = dispbitcode[k];
    
44.   P0 = dispcode[dispbuf[k]];
    
45.   if(k==1)          //加上数码管的dp小数点
    
46.           P0&=0x7f;
    
47.   delay_1ms();         
    
48.   }
    
49. }
    
50. 
    
51. /************
    
52. 读ADC0832函数
    
53. ************/
    
54. 
    
55. //采集并返回
    
56. unsigned int Adc0832(unsigned char channel)     //AD转换，返回结果
    
57. {
    
58.     unsigned char i=0;
    
59.     unsigned char j;
    
60.     unsigned int dat=0;
    
61.     unsigned char ndat=0;
    
62. 
    
63.     if(channel==0)channel=2;
    
64.     if(channel==1)channel=3;
    
65.     ADDI=1;
    
66.     _nop_();
    
67.     _nop_();
    
68.     ADCS=0;//拉低CS端
    
69.     _nop_();
    
70.     _nop_();
    
71.     ADCLK=1;//拉高CLK端
    
72.     _nop_();
    
73.     _nop_();
    
74.     ADCLK=0;//拉低CLK端,形成下降沿1
    
75.     _nop_();
    
76.     _nop_();
    
77.     ADCLK=1;//拉高CLK端
    
78.     ADDI=channel&0x1;
    
79.     _nop_();
    
80.     _nop_();
    
81.     ADCLK=0;//拉低CLK端,形成下降沿2
    
82.     _nop_();
    
83.     _nop_();
    
84.     ADCLK=1;//拉高CLK端
    
85.     ADDI=(channel>>1)&0x1;
    
86.     _nop_();
    
87.     _nop_();
    
88.     ADCLK=0;//拉低CLK端,形成下降沿3
    
89.     ADDI=1;//控制命令结束
    
90.     _nop_();
    
91.     _nop_();
    
92.     dat=0;
    
93.     for(i=0;i<8;i++)
    
94.     {
    
95.         dat|=ADDO;//收数据
    
96.         ADCLK=1;
    
97.         _nop_();
    
98.         _nop_();
    
99.         ADCLK=0;//形成一次时钟脉冲
    
100.         _nop_();
     
101.         _nop_();
     
102.         dat<<=1;
     
103.         if(i==7)dat|=ADDO;
     
104.     }  
     
105.     for(i=0;i<8;i++)
     
106.     {
     
107.         j=0;
     
108.         j=j|ADDO;//收数据
     
109.         ADCLK=1;
     
110.         _nop_();
     
111.         _nop_();
     
112.         ADCLK=0;//形成一次时钟脉冲
     
113.         _nop_();
     
114.         _nop_();
     
115.         j=j<<7;
     
116.         ndat=ndat|j;
     
117.         if(i<7)ndat>>=1;
     
118.     }
     
119.     ADCS=1;//拉低CS端
     
120.     ADCLK=0;//拉低CLK端
     
121.     ADDO=1;//拉高数据端,回到初始状态
     
122.     dat<<=8;
     
123.     dat|=ndat;
     
124.     return(dat);            //return ad k
     
125. }
     
126. 
     
127. //启动I2C总线，即发送起始条件
     
128. void StartI2C()
     
129. {
     
130.         SDA = 1;                              //发送起始条件数据信号
     
131.         _nop_();
     
132.         SCL = 1;
     
133.         _nop_();                                    //起始建立时间大于4.7us
     
134.         _nop_();
     
135.         _nop_();
     
136.         _nop_();
     
137.         _nop_();
     
138.         SDA = 0;                              //发送起始信号
     
139.         _nop_();
     
140.         _nop_();
     
141.         _nop_();
     
142.         _nop_();
     
143.         _nop_();
     
144.         SCL = 0;                                //时钟操作
     
145.         _nop_();
     
146.         _nop_();
     
147. }
     
148. //结束I2C总线，即发送I2C结束条件
     
149. void StopI2C()
     
150. {
     
151.         SDA = 0;                                //发送结束条件的数据信号
     
152.         _nop_();                                      //发送结束条件的时钟信号
     
153.         SCL = 1;                                //结束条件建立时间大于4us
     
154.         _nop_();
     
155.         _nop_();
     
156.         _nop_();
     
157.         _nop_();
     
158.         _nop_();
     
159.         SDA = 1;                                //发送I2C总线结束命令
     
160.         _nop_();
     
161.         _nop_();
     
162.         _nop_();
     
163.         _nop_();
     
164.         _nop_();        
     
165. }
     
166. //发送一个字节的数据
     
167. void        SendByte(unsigned char c)
     
168. {
     
169.         unsigned char BitCnt;
     
170.         for(BitCnt = 0;BitCnt < 8;BitCnt++)                                  //一个字节
     
171.                 {
     
172.                         if((c << BitCnt)& 0x80) SDA = 1;                   //判断发送位
     
173.                         else        SDA = 0;
     
174.                         _nop_();
     
175.                         SCL = 1;                              //时钟线为高，通知从机开始接收数据
     
176.                         _nop_();
     
177.                         _nop_();
     
178.                         _nop_();
     
179.                         _nop_();
     
180.                         _nop_();
     
181.                         SCL = 0;
     
182.                 }
     
183.         _nop_();
     
184.         _nop_();
     
185.         SDA = 1;                                                //释放数据线，准备接受应答位
     
186.         _nop_();
     
187.         _nop_();
     
188.         SCL = 1;
     
189.         _nop_();
     
190.         _nop_();
     
191.         _nop_();
     
192.         if(SDA == 1) bAck =0;
     
193.         else bAck = 1;                                                //判断是否收到应答信号
     
194.         SCL = 0;
     
195.         _nop_();
     
196.         _nop_();
     
197. }
     
198. //接收一个字节的数据
     
199. unsigned char RevByte()
     
200. {
     
201.         unsigned char retc;
     
202.         unsigned char BitCnt;
     
203.         retc = 0;
     
204.         SDA = 1;
     
205.         for(BitCnt=0;BitCnt<8;BitCnt++)
     
206.         {
     
207.                 _nop_();
     
208.                 SCL = 0;                                            //置时钟线为低，准备接收
     
209.                 _nop_();
     
210.                 _nop_();
     
211.                 _nop_();
     
212.                 _nop_();
     
213.                 _nop_();
     
214.                 SCL = 1;                                            //置时钟线为高使得数据有效
     
215.                 _nop_();
     
216.                 _nop_();
     
217.                 retc = retc << 1;                                    //左移补零
     
218.                 if (SDA == 1)
     
219.                 retc = retc + 1;                                     //当数据为1则收到的数据+1
     
220.                 _nop_();
     
221.                 _nop_();
     
222.         }
     
223.         SCL = 0;
     
224.         _nop_();
     
225.         _nop_();
     
226.         return(retc);                                   //返回收到的数据
     
227. }
     
228. 
     
229. //WChipAdd:写器件地址;RChipAdd:读器件地址;InterAdd:内部地址;如写正确则返回数据，
     
230. //否则返回对应错误步骤序号
     
231. //向指定器件的内部指定地址发送一个指定字节
     
232. unsigned char WIICByte(unsigned char WChipAdd,unsigned char InterAdd,unsigned char WIICData)
     
233. {
     
234.         StartI2C();                                                                                      //启动总线
     
235.         SendByte(WChipAdd);                                                        //发送器件地址以及命令
     
236.         if (bAck==1)                                                                                          //收到应答
     
237.         {
     
238.                 SendByte(InterAdd);                                                                //发送内部子地址
     
239.                 if (bAck ==1)
     
240.                 {
     
241.                         SendByte(WIICData);                                                        //发送数据
     
242.                         if(bAck == 1)
     
243.                         {
     
244.                                 StopI2C();                    //停止总线
     
245.                                 return(0xff);
     
246.                         }
     
247.                         else
     
248.                         {
     
249.                                 return(0x03);
     
250.                         }                        
     
251.                 }
     
252.                 else
     
253.                 {
     
254.                         return(0x02);
     
255.                 }
     
256.         }
     
257.         return(0x01);
     
258. }
     
259. //读取指定器件的内部指定地址一个字节数据
     
260. unsigned char RIICByte(unsigned char WChipAdd,unsigned char RChipAdd,unsigned char InterDataAdd)
     
261. {
     
262.         unsigned char TempData;        
     
263.         TempData = 0;
     
264.         StartI2C();                                                                        //启动
     
265.         SendByte(WChipAdd);                                                    //发送器件地址以及读命令
     
266.         if (bAck==1)                                                                            //收到应答
     
267.         {
     
268.                 SendByte(InterDataAdd);                                        //发送内部子地址
     
269.                 if (bAck ==1)
     
270.                 {
     
271.                         StartI2C();
     
272.                         SendByte(RChipAdd);        
     
273.                         if(bAck == 1)
     
274.                         {
     
275.                                 TempData = RevByte();       //接收数据
     
276.                                 StopI2C();                  //停止I2C总线
     
277.                                 return(TempData);           //返回数据
     
278.                         }
     
279.                         else
     
280.                         {
     
281.                                 return(0x03);
     
282.                         }        
     
283.                 }
     
284.                 else
     
285.                 {
     
286.                         return(0x02);
     
287.                 }
     
288.         }
     
289.         else
     
290.         {
     
291.                 return(0x01);
     
292.         }
     
293. }
     
294. 
     
295. 
     
296. void main(void)
     
297. {
     
298.   unsigned int OverCounter = 0;
     
299.   unsigned char ptemp;
     
300.   bit OverFlg = 0;
     
301.   unsigned int temp,ppress = 0;
     
302.   float  press;        
     
303.   while(1)
     
304.   {         
     
305.                      
     
306.           getdata=Adc0832(0);
     
307.           if(14<getdata<243)                                       //当压力值介于15kpa到115kpa之间时，遵循线性变换
     
308.                  {                           
     
309.                   int vary=getdata;                                                //y=(115-15)/(243-13)*X+15kpa                        
     
310.                         press=((10.0/23.0)*vary)+9.3;                        //测试时补偿值为9.3                                                                                                         
     
311.                         temp=(int)(press*10);                  //放大10倍，便于后面的计算
     
312.       if(temp != ppress)
     
313.       {
     
314.         ppress = temp;
     
315.         OverFlg = 1;
     
316.       }                                                                                            
     
317.                         dispbuf[3]=temp/1000;                                     //取压力值百位
     
318.                         dispbuf[2]=(temp%1000)/100;                            //取压力值十位
     
319.                         dispbuf[1]=((temp%1000)%100)/10;                    //取压力值个位
     
320.                         dispbuf[0]=((temp%1000)%100)%10;                        //取压力值十分位
     
321.                         display();
     
322.       if (temp > 100)
     
323.       {
     
324.           if(OverFlg == 1)    //如果是新的一辆车通过
     
325.           {
     
326.             OverCounter++;
     
327.             WIICByte(W24C04ADD,0x01,(OverCounter/0xff));    //低位
     
328.             WIICByte(W24C04ADD,0x02,(OverCounter%0xff));    //高位
     
329. //            ptemp = printf("%f\n",OverCounter);
     
330.             OverFlg = 0;    //清除标志
     
331.           }
     
332.       }
     
333. 
     
334.            }            
     
335.   }
     
336. }
     

复制代码