21ic电子技术开发论坛 › 单片机与嵌入式系统 › 德州仪器MCU › 【MCU方案】+基于msp430f149实现楼宇对讲系统 ...
返回列表 发新帖我要提问

【MCU方案】+基于msp430f149实现楼宇对讲系统

[复制链接]
 楼主| uestc_zyd 发表于 2015-6-26 13:08 | 显示全部楼层 |阅读模式
msp430f149, MCU, 楼宇对讲系统, se, I2c
本帖最后由 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. }


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

相关帖子
dirtwillfly 发表于 2015-6-26 13:36 | 显示全部楼层
回复 赏

举报

JY-DX-JY 发表于 2015-6-26 17:34 | 显示全部楼层
顶一个。
回复 赏

举报

 楼主| uestc_zyd 发表于 2015-6-29 07:59 | 显示全部楼层
JY-DX-JY 发表于 2015-6-26 17:34
顶一个。

3qu
回复 赏

举报

shenmu2012 发表于 2015-6-29 20:21 | 显示全部楼层
整个系统由门口主机、楼层译码器和室内分机组成。门口主机接收用户输入数据、呼叫处理和控制电控锁。整个系统采用总线方式布线，门口主机到楼层译码器采用3总线方式，楼层译码器到室内分机采用无极性的2总线方式，保证即使用户线短路也不会影响整个系统。
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

uestc_zyd

6

主题

64

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部