本帖最后由 uestc_zyd 于 2015-6-26 13:14 编辑

一、功能介绍
楼宇对讲系统应用于智能小区。整个系统由门口主机、楼层译码器和室内分机组成。门口主机接收用户输入数据、呼叫处理和控制电控锁。整个系统采用总线方式布线，门口主机到楼层译码器采用3总线方式，楼层译码器到室内分机采用无极性的2总线方式，保证即使用户线短路也不会影响整个系统。
主机发出编码信息（如房间号码），楼层译码器根据接收到的数据进行译码，若为本层的某个房间则将分机接通，主机检测到线路状态后就可以发送振铃信号，分机应答后可以进行通话，并给出开锁信号，即主机在收到分机的开锁信号后会打开电控锁。
二、方案描述
硬件系统包括3个部分：主机、楼层译码器、分机。软件系统主要包括显示模块、存储器操作模块、键盘输入模块、拨号处理模块、主处理模块。
系统构成如下图：

1、硬件主机设计
主机主要包括键盘输入电路、存储器电路、逻辑控制电路、比较器电路、驱动电路和音频处理电路。键盘输入电路主要用于接收用户输入的数据，如密码设置、振铃时间设置、房间号码设置等。存储器电路主要用于存储系统信息，如房间模式、密码。逻辑控制电路主要产生某些逻辑控制信号，如开锁信号、对话信号、振铃信号。比较器电路用于判断分机的状态，如摘机、挂机等。音频电路主要实现对讲功能。
2、楼层译码器设计
用来接收主机发出的编码数据，并对接收到的编码数据，并对接收到的编码数据进行处理，如果是本楼的分机则接通被呼叫的分机。楼层译码器选用HT12D芯片实现。主机发出的编码数据经过HT12D芯片译码，如果编码数据中的地址部分正好和该译码器的地址相同，那么HT12D芯片就在D8/D9/D10/D11中的某一个管脚输出高电平，通过这个高电平来接通分机。

3、软件部分在下节中介绍
三、软件部分
1、显示模块
显示程序是通过P1.2管脚模拟移位时钟信号，P1.0管脚在输出时钟的控制下一位一位地输出数据，P1.1管脚给出锁存信号将数据显示出来。整个显示程序主要由端口初始化、管脚高低电平产生、数据串行输出3个部分组成。

1. #include <msp430x14x.h>
   
2. #include "led.h"
   
3. 
   
4. void Init_Port(void)
   
5. {
   
6. //将P1口所有的管脚在初始化的时候设置为输入方式
   
7. P1DIR = 0;
   
8. //将P1口所有的管脚设置为一般I/O口
   
9. P1SEL = 0;
   
10. 
    
11. // 将P1.0 P1.1 P1.2 设置为输出方向
    
12. P1DIR |= BIT0;
    
13. P1DIR |= BIT1;
    
14. P1DIR |= BIT2;
    
15. // 将P1.3 P1.4 P1.5 设置为输出方向
    
16. P1DIR |= BIT3;
    
17. P1DIR |= BIT4;
    
18. P1DIR |= BIT5;
    
19. 
    
20. //将P2口所有的管脚在初始化的时候设置为输入方式
    
21. P2DIR = 0;
    
22. //将P2口所有的管脚设置为一般I/O口
    
23. P2SEL = 0;
    
24. //将中断寄存器清零
    
25. P2IE = 0;
    
26. P2IES = 0;
    
27. P2IFG = 0;
    
28. //管脚 P2.0 使能中断
    
29. P2IE |= BIT0;
    
30. //对应的管脚由低到高电平跳变使相应的标志置位
    
31. P2IES &= ~(BIT0);
    
32. return;
    
33. }
    
34. void SHCLK_Hi(void)
    
35. {
    
36. //P1.2管脚输出高电平
    
37. P1OUT |= BIT2;
    
38. return;
    
39. }
    
40. void SHCLK_Lo(void)
    
41. {
    
42. //P1.2管脚输出低电平
    
43. P1OUT &= ~(BIT2);
    
44. return;
    
45. }
    
46. void STCLK_Hi(void)
    
47. {
    
48. //P1.1管脚输出高电平
    
49. P1OUT |= BIT1;
    
50. return;
    
51. }
    
52. void STCLK_Lo(void)
    
53. {
    
54. //P1.1管脚输出低电平
    
55. P1OUT &= ~(BIT1);
    
56. return;
    
57. }
    
58. void DataOut(unsigned char nValue)
    
59. {
    
60. int i;
    
61. int j;
    
62. for(i = 0;i < 8;i++)
    
63. {
    
64. if ((nValue & 0x01) == 1)
    
65. {
    
66. P1OUT |= BIT0;//输出高电平
    
67. }
    
68. else
    
69. {
    
70. P1OUT &= ~(BIT0);//输出低电平
    
71. }
    
72. SHCLK_Hi();//时钟高电平，上升沿有效
    
73. for(j = 10; j > 0; j--) ;//延迟一点时间
    
74. SHCLK_Lo();//时钟低电平
    
75. for(j = 10; j > 0; j--) ;
    
76. nValue >>= 1;
    
77. }
    
78. return;
    
79. }
    
80. 
    
81. 
    
82. void Init_CLK(void)
    
83. {
    
84. unsigned int i;
    
85. //将寄存器的内容清零
    
86. //XT2震荡器开启
    
87. //LFTX1工作在低频模式
    
88. //ACLK的分频因子为1
    
89. BCSCTL1 = 0X00;
    
90. 
    
91. do
    
92. {
    
93. // 清除OSCFault标志
    
94. IFG1 &= ~OFIFG;
    
95. for (i = 0x20; i > 0; i--);
    
96. }
    
97. while ((IFG1 & OFIFG) == OFIFG); // 如果OSCFault =1
    
98. 
    
99. //将寄存器的内容清零
    
100. BCSCTL2 = 0X00;
     
101. //MCLK的时钟源为TX2CLK，分频因子为1
     
102. BCSCTL2 += SELM1;
     
103. //SMCLK的时钟源为TX2CLK，分频因子为1
     
104. BCSCTL2 += SELS;
     
105. }

复制代码
2、I2C模块（存储器操作模块）
采用串行存储器24LC02B通过I2C实现与MSP430的连接。I2C的时序包括起始条件、数据传输、确认、停止条件。

1. #include "I2C.h"
   
2. 
   
3. void I2C_Initial( void )
   
4. {
   
5. P1DIR |= SCL; //将SCL管脚（P1.3)设置为输出管脚
   
6. I2C_Set_sck_low();
   
7. I2C_STOP();
   
8. Delay_ms(10);
   
9. return;
   
10. }
    
11. void I2C_Set_sda_high( void )
    
12. {
    
13. P1DIR |= SDA; //将SDA设置为输出模式
    
14. P1OUT |= SDA; //SDA管脚输出为高电平
    
15. 
    
16. _NOP();
    
17. _NOP();
    
18. return;
    
19. }
    
20. void I2C_Set_sda_low ( void )
    
21. {
    
22. P1DIR |= SDA; //将SDA设置为输出模式
    
23. P1OUT &= ~(SDA); //SDA管脚输出为低电平
    
24. 
    
25. _NOP();
    
26. _NOP();
    
27. return;
    
28. }
    
29. void I2C_Set_sck_high( void )
    
30. {
    
31. P1DIR |= SCL; //将SCL设置为输出模式
    
32. P1OUT |= SCL; //SCL管脚输出为高电平
    
33. 
    
34. _NOP();
    
35. _NOP();
    
36. return;
    
37. }
    
38. void I2C_Set_sck_low ( void )
    
39. {
    
40. P1DIR |= SCL; //将SCL设置为输出模式
    
41. P1OUT &= ~(SCL); //SCL管脚输出为低电平
    
42. 
    
43. _NOP();
    
44. _NOP();
    
45. return;
    
46. }
    
47. int I2C_GetACK(void)
    
48. {
    
49. int nTemp = 0;
    
50. int j;
    
51. 
    
52. _NOP();
    
53. _NOP();
    
54. I2C_Set_sck_low();
    
55. for(j = 30;j > 0;j--);
    
56. P1DIR &= ~(SDA); //将SDA设置为输入方向
    
57. //I2C_Set_sda_high();
    
58. I2C_Set_sck_high();
    
59. 
    
60. for(j = 30;j > 0;j--);
    
61. nTemp = (int)(P1IN & SDA); //获得数据
    
62. 
    
63. I2C_Set_sck_low();
    
64. 
    
65. return (nTemp & SDA);
    
66. }
    
67. void I2C_SetACK(void)
    
68. {
    
69. I2C_Set_sck_low();
    
70. I2C_Set_sda_low();
    
71. I2C_Set_sck_high();
    
72. I2C_Set_sck_low();
    
73. return;
    
74. }
    
75. void I2C_SetNAk(void)
    
76. {
    
77. I2C_Set_sck_low();
    
78. I2C_Set_sda_high();
    
79. I2C_Set_sck_high();
    
80. I2C_Set_sck_low();
    
81. return;
    
82. }
    
83. void I2C_START(void)
    
84. {
    
85. int i;
    
86. 
    
87. I2C_Set_sda_high();
    
88. for(i = 5;i > 0;i--);
    
89. I2C_Set_sck_high();
    
90. for(i = 5;i > 0;i--);
    
91. I2C_Set_sda_low();
    
92. for(i = 5;i > 0;i--);
    
93. I2C_Set_sck_low();
    
94. return;
    
95. }
    
96. void I2C_STOP(void)
    
97. {
    
98. int i;
    
99. 
    
100. I2C_Set_sda_low();
     
101. for(i = 5;i > 0;i--);
     
102. I2C_Set_sck_low();
     
103. for(i = 5;i > 0;i--);
     
104. I2C_Set_sck_high();
     
105. for(i = 5;i > 0;i--);
     
106. I2C_Set_sda_high();
     
107. for(i = 5;i > 0;i--);
     
108. I2C_Set_sck_low();
     
109. Delay_ms(10); //延迟一点时间
     
110. 
     
111. return;
     
112. }
     
113. void I2C_TxByte(int nValue)
     
114. {
     
115. int i;
     
116. int j;
     
117. 
     
118. for(i = 0;i < 8;i++)
     
119. {
     
120. if(nValue & 0x80)
     
121. I2C_Set_sda_high();
     
122. else
     
123. I2C_Set_sda_low();
     
124. for(j = 30;j > 0;j--);
     
125. I2C_Set_sck_high();
     
126. nValue <<= 1;
     
127. for(j = 30;j > 0;j--);
     
128. I2C_Set_sck_low();
     
129. }
     
130. 
     
131. return;
     
132. }
     
133. /////////////////////////////////////////////
     
134. // 接收是从 LSB 到 MSB 的顺序
     
135. int I2C_RxByte(void)
     
136. {
     
137. int nTemp = 0;
     
138. int i;
     
139. int j;
     
140. 
     
141. I2C_Set_sda_high();
     
142. 
     
143. P1DIR &= ~(SDA); //将SDA管脚设置为输入方向
     
144. _NOP();
     
145. _NOP();
     
146. _NOP();
     
147. _NOP();
     
148. for(i = 0;i < 8;i++)
     
149. {
     
150. I2C_Set_sck_high();
     
151. 
     
152. if(P1IN & SDA)
     
153. {
     
154. nTemp |= (0x01 << i);
     
155. }
     
156. for(j = 30;j > 0;j--);
     
157. I2C_Set_sck_low();
     
158. }
     
159. 
     
160. return nTemp;
     
161. }
     
162. void I2C_Write(char nAddr,char nValue)
     
163. {
     
164. int nTemp = 0xA0;//写命令
     
165. // 启动数据总线
     
166. I2C_START();
     
167. // 发送控制字节
     
168. I2C_TxByte(nTemp);
     
169. // 等待 ACK
     
170. nTemp = I2C_GetACK();
     
171. 
     
172. // 发送地址字节
     
173. I2C_TxByte(nAddr);
     
174. // 等待 ACK
     
175. nTemp = I2C_GetACK();
     
176. 
     
177. // 发送数据字节
     
178. I2C_TxByte(nValue);
     
179. // 等待 ACK
     
180. nTemp = I2C_GetACK();
     
181. 
     
182. // 停止总线
     
183. I2C_STOP();
     
184. return;
     
185. }
     
186. int PageWrite(char nAddr,char pBuf[])
     
187. {
     
188. int i;
     
189. int nTemp = 0xA0;//写命令
     
190. // 启动数据总线
     
191. I2C_START();
     
192. // 发送控制字节
     
193. I2C_TxByte(nTemp);
     
194. // 等待 ACK
     
195. nTemp = I2C_GetACK();
     
196. if(nTemp & BIT3) return 0;
     
197. 
     
198. // 发送地址字节
     
199. I2C_TxByte(nAddr);
     
200. // 等待 ACK
     
201. nTemp = I2C_GetACK();
     
202. if(nTemp & BIT3) return 0;
     
203. 
     
204. // 发送数据字节
     
205. for(i = 0; i < 8;i++)
     
206. {
     
207. I2C_TxByte(pBuf[0]);
     
208. // 等待 ACK
     
209. nTemp = I2C_GetACK();
     
210. if(nTemp & BIT3) return 0;
     
211. }
     
212. 
     
213. // 停止总线
     
214. I2C_STOP();
     
215. return (nTemp & SDA);
     
216. }
     
217. char I2C_Read(int nAddr)
     
218. {
     
219. int nRes = -1;
     
220. //写命令
     
221. int nTemp = 0xA0;
     
222. // 启动数据总线
     
223. I2C_START();
     
224. // 发送控制字节
     
225. I2C_TxByte(nTemp);
     
226. // 等待 ACK
     
227. nTemp = I2C_GetACK();
     
228. 
     
229. // 发送地址字节
     
230. I2C_TxByte(nAddr);
     
231. // 等待 ACK
     
232. nTemp = I2C_GetACK();
     
233. 
     
234. // 启动数据总线
     
235. I2C_START();
     
236. // 发送控制字节
     
237. nTemp = 0xA1;
     
238. I2C_TxByte(nTemp);
     
239. // 等待 ACK
     
240. nTemp = I2C_GetACK();
     
241. 
     
242. //读取数据
     
243. nRes = I2C_RxByte();
     
244. 
     
245. // 停止总线
     
246. I2C_STOP();
     
247. //成功返回
     
248. return nRes;
     
249. }
     
250. int ReadSeq(char nAddr, char nValue[], int nLen)
     
251. {
     
252. int i;
     
253. //写命令
     
254. int nTemp = 0xA0;
     
255. // 启动数据总线
     
256. I2C_START();
     
257. // 发送控制字节
     
258. I2C_TxByte(nTemp);
     
259. // 等待 ACK
     
260. nTemp = I2C_GetACK();
     
261. if(nTemp & BIT3) return 0;
     
262. 
     
263. // 发送地址字节
     
264. I2C_TxByte(nAddr);
     
265. // 等待 ACK
     
266. nTemp = I2C_GetACK();
     
267. if(nTemp & BIT3) return 0;
     
268. 
     
269. // 启动数据总线
     
270. I2C_START();
     
271. // 发送控制字节
     
272. nTemp = 0xA1;
     
273. I2C_TxByte(nTemp);
     
274. // 等待 ACK
     
275. nTemp = I2C_GetACK();
     
276. if(nTemp & BIT3) return 0;
     
277. 
     
278. //读取数据
     
279. for(i = 0; i < nLen; i++)
     
280. {
     
281. //读一个字节数据
     
282. nValue[i] = I2C_RxByte();
     
283. //发送ACK
     
284. I2C_SetACK();
     
285. }
     
286. 
     
287. // 停止总线
     
288. I2C_STOP();
     
289. //成功返回
     
290. return 1;
     
291. }
     
292. void Delay_ms(unsigned long nValue)//毫秒为单位，8MHz为主时钟
     
293. {
     
294. unsigned long nCount;
     
295. int i;
     
296. unsigned long j;
     
297. nCount = 2667;
     
298. for(i = nValue;i > 0;i--)
     
299. {
     
300. for(j = nCount;j > 0;j--);
     
301. }
     
302. return;
     
303. }
     
304. void Delay_us(unsigned long nValue)//微秒为单位，8MHz为主时钟
     
305. {
     
306. int nCount;
     
307. int i;
     
308. int j;
     
309. nCount = 3;
     
310. for(i = nValue;i > 0;i--)
     
311. {
     
312. for(j = nCount;j > 0;j--);
     
313. }
     
314. return;
     
315. }
     
316. 
     

复制代码3、键盘输入模块
矩阵键盘电路利用MSP430的一般I/O口来进行扩展设计，矩阵键盘有行、列线组成，通过扫描来获取键盘的输入，读取线的状态就可以判断哪个键被按下。
一般IO口方式的程序设计：

1. #include <msp430x14x.h>
   
2. 
   
3. void Delay(void);
   
4. int KeyScan(void);
   
5. int KeyProcess(void);
   
6. void Init_Port(void)
   
7. {
   
8. //将P1口所有的管脚在初始化的时候设置为输入方式
   
9. P1DIR = 0;
   
10. 
    
11. //将P1口所有的管脚设置为一般I/O口
    
12. P1SEL = 0;
    
13. 
    
14. // 将P1.4 P1.5 P1.6 P1.7设置为输出方向
    
15. P1DIR |= BIT4;
    
16. P1DIR |= BIT5;
    
17. P1DIR |= BIT6;
    
18. P1DIR |= BIT7;
    
19. 
    
20. //先输出低电平
    
21. P1OUT = 0x00;
    
22. return;
    
23. }
    
24. int KeyScan(void)
    
25. {
    
26. int nP10,nP11,nP12,nP13;
    
27. int nRes = 0;
    
28. for(;;)
    
29. {
    
30. //读取各个管脚的状态
    
31. nP10 = P1IN & BIT0;
    
32. nP11 = (P1IN & BIT1) >> 1;
    
33. nP12 = (P1IN & BIT2) >> 2;
    
34. nP13 = (P1IN & BIT3) >> 3;
    
35. 
    
36. //是否有键被按下
    
37. if(nP10 == 0 || nP11 == 0 || nP12 == 0 || nP13 == 0)
    
38. {
    
39. //有键被按下
    
40. break;
    
41. }
    
42. 
    
43. }
    
44. Delay(); //延时一点时间，消除抖动
    
45. //读取各个管脚的状态
    
46. nP10 = P1IN & BIT0;
    
47. nP11 = (P1IN & BIT1) >> 1;
    
48. nP12 = (P1IN & BIT2) >> 2;
    
49. nP13 = (P1IN & BIT3) >> 3;
    
50. 
    
51. //是否有键被按下
    
52. if(nP10 == 0 || nP11 == 0 || nP12 == 0 || nP13 == 0)
    
53. {
    
54. //有键被按下，进行键盘输入分析
    
55. nRes = KeyProcess();
    
56. }
    
57. else return -1;//没有输入，为干扰
    
58. 
    
59. return nRes;
    
60. }
    
61. void Delay(void)
    
62. {
    
63. int i;
    
64. for(i = 100;i--;i > 0) ;//延时一点时间
    
65. }
    
66. int KeyProcess(void)
    
67. {
    
68. int nRes = 0;
    
69. int nP10;
    
70. int nP11;
    
71. int nP12;
    
72. int nP13;
    
73. //P1.4输出低电平
    
74. P1OUT &= ~(BIT4);
    
75. nP10 = P1IN & BIT0;
    
76. if (nP10 == 0) nRes = 13;
    
77. nP11 = (P1IN & BIT1) >> 1;
    
78. if (nP11 == 0) nRes = 14;
    
79. nP12 = (P1IN & BIT2) >> 2;
    
80. if (nP12 == 0) nRes = 15;
    
81. nP13 = (P1IN & BIT3) >> 3;
    
82. if (nP13 == 0) nRes = 16;
    
83. //P1.5输出低电平
    
84. P1OUT &= ~(BIT4);
    
85. nP10 = P1IN & BIT0;
    
86. if (nP10 == 0) nRes = 9;
    
87. nP11 = (P1IN & BIT1) >> 1;
    
88. if (nP11 == 0) nRes = 10;
    
89. nP12 = (P1IN & BIT2) >> 2;
    
90. if (nP12 == 0) nRes = 11;
    
91. nP13 = (P1IN & BIT3) >> 3;
    
92. if (nP13 == 0) nRes = 12;
    
93. //P1.6输出低电平
    
94. P1OUT &= ~(BIT4);
    
95. nP10 = P1IN & BIT0;
    
96. if (nP10 == 0) nRes = 5;
    
97. nP11 = (P1IN & BIT1) >> 1;
    
98. if (nP11 == 0) nRes = 6;
    
99. nP12 = (P1IN & BIT2) >> 2;
    
100. if (nP12 == 0) nRes = 7;
     
101. nP13 = (P1IN & BIT3) >> 3;
     
102. if (nP13 == 0) nRes = 8;
     
103. //P1.7输出低电平
     
104. P1OUT &= ~(BIT4);
     
105. nP10 = P1IN & BIT0;
     
106. if (nP10 == 0) nRes = 1;
     
107. nP11 = (P1IN & BIT1) >> 1;
     
108. if (nP11 == 0) nRes = 2;
     
109. nP12 = (P1IN & BIT2) >> 2;
     
110. if (nP12 == 0) nRes = 3;
     
111. nP13 = (P1IN & BIT3) >> 3;
     
112. if (nP13 == 0) nRes = 4;
     
113. 
     
114. P1OUT = 0x00;//恢复以前值。
     
115. 
     
116. //读取各个管脚的状态
     
117. nP10 = P1IN & BIT0;
     
118. nP11 = (P1IN & BIT1) >> 1;
     
119. nP12 = (P1IN & BIT2) >> 2;
     
120. nP13 = (P1IN & BIT3) >> 3;
     
121. for(;;)
     
122. {
     
123. if(nP10 == 1 && nP11 == 1 && nP12 == 1 && nP13 == 1)
     
124. {
     
125. //等待松开按键
     
126. break;
     
127. }
     
128. }
     
129. return nRes;
     
130. }
     
131. void Init_CLK(void)
     
132. {
     
133. unsigned int i;
     
134. BCSCTL1 = 0X00; //将寄存器的内容清零
     
135. //XT2震荡器开启
     
136. //LFTX1工作在低频模式
     
137. //ACLK的分频因子为1
     
138. 
     
139. do
     
140. {
     
141. IFG1 &= ~OFIFG; // 清除OSCFault标志
     
142. for (i = 0x20; i > 0; i--);
     
143. }
     
144. while ((IFG1 & OFIFG) == OFIFG); // 如果OSCFault =1
     
145. 
     
146. BCSCTL2 = 0X00; //将寄存器的内容清零
     
147. BCSCTL2 += SELM1; //MCLK的时钟源为TX2CLK，分频因子为1
     
148. BCSCTL2 += SELS; //SMCLK的时钟源为TX2CLK，分频因子为1
     
149. }

复制代码中断功能方式的程序：

1. #include <msp430x14x.h>
   
2. void Init_Port(void)
   
3. {
   
4. //将P1口所有的管脚在初始化的时候设置为输入方式
   
5. P1DIR = 0;
   
6. 
   
7. //将P1口所有的管脚设置为一般I/O口
   
8. P1SEL = 0;
   
9. 
   
10. // 将P1.4 P1.5 P1.6 P1.7设置为输出方向
    
11. P1DIR |= BIT4;
    
12. P1DIR |= BIT5;
    
13. P1DIR |= BIT6;
    
14. P1DIR |= BIT7;
    
15. 
    
16. //先输出低电平
    
17. P1OUT = 0x00;
    
18. 
    
19. // 将中断寄存器清零
    
20. P1IE = 0;
    
21. P1IES = 0;
    
22. P1IFG = 0;
    
23. //打开管脚的中断功能
    
24. //对应的管脚由高到低电平跳变使相应的标志置位
    
25. P1IE |= BIT0;
    
26. P1IES |= BIT0;
    
27. P1IE |= BIT1;
    
28. P1IES |= BIT1;
    
29. P1IE |= BIT2;
    
30. P1IES |= BIT2;
    
31. P1IE |= BIT3;
    
32. P1IES |= BIT3;
    
33. _EINT();//打开中断
    
34. return;
    
35. }
    
36. void Delay(void)
    
37. {
    
38. int i;
    
39. for(i = 100;i--;i > 0) ;//延时一点时间
    
40. }
    
41. int KeyProcess(void)
    
42. {
    
43. int nP10,nP11,nP12,nP13;
    
44. int nRes = 0;
    
45. //P1.4输出低电平
    
46. P1OUT &= ~(BIT4);
    
47. nP10 = P1IN & BIT0;
    
48. if (nP10 == 0) nRes = 13;
    
49. nP11 = P1IN & BIT1;
    
50. if (nP11 == 0) nRes = 14;
    
51. nP12 = P1IN & BIT2;
    
52. if (nP12 == 0) nRes = 15;
    
53. nP13 = P1IN & BIT3;
    
54. if (nP13 == 0) nRes = 16;
    
55. //P1.5输出低电平
    
56. P1OUT &= ~(BIT4);
    
57. nP10 = P1IN & BIT0;
    
58. if (nP10 == 0) nRes = 9;
    
59. nP11 = P1IN & BIT1;
    
60. if (nP11 == 0) nRes = 10;
    
61. nP12 = P1IN & BIT2;
    
62. if (nP12 == 0) nRes = 11;
    
63. nP13 = P1IN & BIT3;
    
64. if (nP13 == 0) nRes = 12;
    
65. //P1.6输出低电平
    
66. P1OUT &= ~(BIT4);
    
67. nP10 = P1IN & BIT0;
    
68. if (nP10 == 0) nRes = 5;
    
69. nP11 = P1IN & BIT1;
    
70. if (nP11 == 0) nRes = 6;
    
71. nP12 = P1IN & BIT2;
    
72. if (nP12 == 0) nRes = 7;
    
73. nP13 = P1IN & BIT3;
    
74. if (nP13 == 0) nRes = 8;
    
75. //P1.7输出低电平
    
76. P1OUT &= ~(BIT4);
    
77. nP10 = P1IN & BIT0;
    
78. if (nP10 == 0) nRes = 1;
    
79. nP11 = P1IN & BIT1;
    
80. if (nP11 == 0) nRes = 2;
    
81. nP12 = P1IN & BIT2;
    
82. if (nP12 == 0) nRes = 3;
    
83. nP13 = P1IN & BIT3;
    
84. if (nP13 == 0) nRes = 4;
    
85. 
    
86. P1OUT = 0x00;//恢复以前值。
    
87. 
    
88. //读取各个管脚的状态
    
89. nP10 = P1IN & BIT0;
    
90. nP11 = P1IN & BIT1;
    
91. nP12 = P1IN & BIT2;
    
92. nP13 = P1IN & BIT3;
    
93. for(;;)
    
94. {
    
95. if(nP10 == 1 && nP11 == 1 && nP12 == 1 && nP13 == 1)
    
96. {
    
97. //等待松开按键
    
98. break;
    
99. }
    
100. }
     
101. return nRes;
     
102. }
     
103. // 处理来自端口 1 的中断
     
104. interrupt [PORT1_VECTOR] void PORT_ISR(void)
     
105. {
     
106. Delay();
     
107. KeyProcess();
     
108. if(P1IFG & BIT0)
     
109. {
     
110. P1IFG &= ~(BIT0);// 清除中断标志位
     
111. }
     
112. if(P1IFG & BIT1)
     
113. {
     
114. P1IFG &= ~(BIT1);// 清除中断标志位
     
115. }
     
116. if(P1IFG & BIT2)
     
117. {
     
118. P1IFG &= ~(BIT2);// 清除中断标志位
     
119. }
     
120. if(P1IFG & BIT3)
     
121. {
     
122. P1IFG &= ~(BIT3);// 清除中断标志位
     
123. }
     
124. }
     
125. void Init_CLK(void)
     
126. {
     
127. unsigned int i;
     
128. BCSCTL1 = 0X00; //将寄存器的内容清零
     
129. //XT2震荡器开启
     
130. //LFTX1工作在低频模式
     
131. //ACLK的分频因子为1
     
132. 
     
133. do
     
134. {
     
135. IFG1 &= ~OFIFG; // 清除OSCFault标志
     
136. for (i = 0x20; i > 0; i--);
     
137. }
     
138. while ((IFG1 & OFIFG) == OFIFG); // 如果OSCFault =1
     
139. 
     
140. BCSCTL2 = 0X00; //将寄存器的内容清零
     
141. BCSCTL2 += SELM1; //MCLK的时钟源为TX2CLK，分频因子为1
     
142. BCSCTL2 += SELS; //SMCLK的时钟源为TX2CLK，分频因子为1
     
143. }

复制代码4、发送编码数据处理
发送的编码数据总共有12位，前8位为地址数据，后4位为数据信息，首先要发送起始信息，然后再将编码数据一位一位地发送。

1. //发送编码数据
   
2. void Send_data(unsigned int numCode) //要发送的数据是numCode
   
3. {
   
4. int CodeBit;
   
5. int SendBit;
   
6. int nHigh;
   
7. int nLow;
   
8. int n;
   
9. int i;
   
10. 
    
11. nLow = numCode & 0x0f;
    
12. nHigh = numCode >> 4;
    
13. 
    
14. Send_Pre();
    
15. for(i = 0;i < 8;i++)
    
16. {
    
17. SendBit = nHigh & 0x01;
    
18. if(SendBit == 1)
    
19. Send_Bit1();
    
20. else
    
21. Send_Bit0();
    
22. nHigh >>= 1;
    
23. }
    
24. for(i = 0;i < 4;i++)
    
25. {
    
26. SendBit = nLow & 0x01;
    
27. if(SendBit == 1)
    
28. Send_Bit1();
    
29. else
    
30. Send_Bit0();
    
31. nLow >>= 1;
    
32. }
    
33. }
    

复制代码5、拨号处理
拨号处理主要根据线路状态来判断分机状态，并根据分机的不同状态进行相应处理。线路状态的检测是通过比较器输入模块进行处理的。拨号处理的具体程序如下：

1. void DialAndProcess(void)
   
2. {
   
3. int i;
   
4. int nBit5;
   
5. int nBit6;
   
6. //判断选通房间分机是否存在
   
7. Delay();
   
8. Delay();
   
9. Delay();
   
10. nBit5 = (P1IN & BIT5) >> 5;
    
11. nBit6 = (P1IN & BIT6) >> 6;
    
12. if((nBit6 == 1) && (nBit5 == 0))
    
13. {
    
14. //分机存在
    
15. //清除锁存信号
    
16. STCLK_Lo();
    
17. //输出1
    
18. DataOut(nLed[1]);
    
19. //给锁存信号，显示数据
    
20. STCLK_Hi();
    
21. 
    
22. //判断分机是否短路
    
23. nBit5 = (P1IN & BIT5) >> 5;
    
24. nBit6 = (P1IN & BIT6) >> 6;
    
25. if((nBit6 == 1) && (nBit5 == 1))
    
26. {
    
27. //分机短路
    
28. //提示音三次
    
29. Ring();
    
30. P4OUT &= ~(BIT2);
    
31. Delay_1s();
    
32. Ring();
    
33. P4OUT &= ~(BIT2);
    
34. Delay_1s();
    
35. Ring();
    
36. Delay_1s();
    
37. P4OUT &= ~(BIT2);
    
38. }//分机短路
    
39. else
    
40. {
    
41. //分机不短路
    
42. //发出振铃信号
    
43. //初始化摘机标志，为0代表没有摘机
    
44. ZhaijiFlag = 0;
    
45. //定时器中断允许
    
46. TBCTL |= TBCLR;
    
47. TBCCTL0 |= CCIE;
    
48. //在振铃时间30s内
    
49. while(RingFlag)
    
50. {
    
51. //发出振铃信号
    
52. Ring();
    
53. Delay_1s();
    
54. P4OUT &= ~(BIT2);
    
55. //判断分机是否摘机
    
56. nBit5 = (P1IN & BIT5) >> 5;
    
57. nBit6 = (P1IN & BIT6) >> 6;
    
58. if((nBit6 == 0) && (nBit5 == 0))
    
59. {
    
60. //分机摘机
    
61. //摘机标志为1，代表摘机
    
62. ZhaijiFlag = 1;
    
63. }//分机摘机
    
64. if(ZhaijiFlag == 1) break;
    
65. }//振铃时间内
    
66. 
    
67. //定时器中断禁止
    
68. TBCCTL0 &= ~(CCIE);
    
69. 
    
70. //假如分机摘机
    
71. if(ZhaijiFlag == 1)
    
72. {
    
73. //分机摘机
    
74. //对话
    
75. //定时器中断允许
    
76. TBCTL |= TBCLR;
    
77. TBCCTL0 |= CCIE;
    
78. P4OUT &= ~(BIT2);
    
79. DialogFlag = 1;
    
80. //在对话时间60s内
    
81. while( DialogFlag)
    
82. {
    
83. //打开对讲
    
84. P4OUT |= BIT0;
    
85. P4OUT |= BIT1;
    
86. P4OUT &= ~(BIT2);
    
87. P4OUT &= ~(BIT4);
    
88. 
    
89. //判断分机是否挂机
    
90. nBit5 = (P1IN & BIT5) >> 5;
    
91. nBit6 = (P1IN & BIT6) >> 6;
    
92. if((nBit6 == 0) && (nBit5 == 0))
    
93. {
    
94. //分机挂机
    
95. //关闭对讲
    
96. P4OUT &= ~(BIT0);
    
97. P4OUT &= ~(BIT3);
    
98. }//分机挂机，返回
    
99. else
    
100. {
     
101. //分机没有挂机
     
102. //判断是否开锁
     
103. nBit5 = (P1IN & BIT5) >> 5;
     
104. nBit6 = (P1IN & BIT6) >> 6;
     
105. if((nBit6 == 1) && (nBit5 == 1))
     
106. {
     
107. //分机开锁
     
108. for(i = 0;i < 10;i++)
     
109. {
     
110. //开电锁命令
     
111. P4OUT &= ~(BIT1);
     
112. }
     
113. break;
     
114. }//分机开锁
     
115. else//不开锁
     
116. {
     
117. ;
     
118. }//不开锁
     
119. }//分机没有挂机
     
120. }//对话时间内
     
121. 
     
122. //定时器中断禁止
     
123. TBCCTL0 &= ~(CCIE);
     
124. }//分机摘机
     
125. }//分机不短路
     
126. }//分机存在
     
127. else //分机不存在
     
128. {
     
129. //清除锁存信号
     
130. STCLK_Lo();
     
131. //输出0
     
132. DataOut(nLed[0]);
     
133. //给锁存信号，显示数据
     
134. STCLK_Hi();
     
135. 
     
136. //提示音两次
     
137. Ring();
     
138. Delay_1s();
     
139. Ring();
     
140. }
     
141. 
     
142. nidle = 1; //重新开始扫描键盘
     
143. }

复制代码