host.c
上传用户:xs588588
上传日期:2021-03-30
资源大小:242k
文件大小:28k
源码类别:

DSP编程

开发平台:

C/C++

  1. /*********************************************************/
  2. /*   */
  3. /* 楼宇对讲系统主机程序 Version 1.0  */
  4. /*  */
  5. /*********************************************************/
  6. #include <msp430x14x.h>
  7. #include "led.h"
  8. #include "I2C.h"
  9. void Port_init(void);
  10. void Send_Bit1(void);
  11. void Send_Bit0(void);
  12. void Send_Pre(void);
  13. void Init_TimerB(void);
  14. int KeyServe(void);
  15. int Keyscan(void);
  16. void Delay(void);
  17. void Delay_1s(void);
  18. //数据处理模块
  19. void Ring(void);
  20. int Process_Data(char nIn[],int nLen,char nRoom_Mode);
  21. void DialAndProcess(void);
  22. void Send_data(unsigned int numCode);
  23. char Sub_Process(char nTemp,char nIn[],int nLen,char nRoom_Mode);
  24. //void Send_code(unsigned int Room_mode,unsigned int numCode);
  25. //特殊功能处理模块
  26. char Administrator(char nTemp,char nIn[],int nLen,char nRoom_Mode);// 管理员设置用户密码和修改密码
  27. char OpenDoorSelf(char nTemp,char nIn[],int nLen,char nRoom_Mode);// 密码开门
  28. char SetRoomMode(char nTemp,char nIn[],int nLen);//管理员设置房号模式
  29. char SetRingTime(char nTemp,char nIn[],int nLen);//管理员设置振铃时间
  30. char SetDialogTime(char nTemp,char nIn[],int nLen);//管理员设置对话时间
  31. char SetMasterPass(char nTemp,char nIn[],int nLen);//管理员设置密码
  32. char AdministratorFlag;//进入管理员设置用户密码模式的标志
  33. //G-U,#-P,*-L
  34. unsigned char nLed[]={
  35.  0x3f,0x06,0x5b,0x4f, /* 0 1 2 3*/
  36.  0x66,0x6d,0x7d,0x07, /* 4 5 6 7 */
  37.  0x7f,0x6f,0x77,0x7c, /* 8 9 A B */
  38.  0x39,0x5e,0x79,0x71  /* C D E F */
  39. };
  40. int nRoom_Mode; //房间模式
  41. int nSecond;
  42. char nidle;
  43. unsigned int RingFlag,DialogFlag,ZhaijiFlag;
  44. char Ring_time,Dialog_time;      //单位时间为S
  45. int nRing;
  46. int nDialog;
  47.     
  48. /*********************************************************/
  49. /*   */
  50. /* 主处理程序    */
  51. /*  */
  52. /*********************************************************/
  53. int main(void)
  54. {
  55.     char nTemp;
  56.     char nFlag;
  57.     char nResult;
  58.     char nCount;
  59.     int nOther_Count;
  60.     char nidle;
  61.     char numRoom[8];     //房间键盘扫描值
  62. // 关闭看门狗
  63. WDTCTL = WDTPW + WDTHOLD;   
  64. //关闭中断
  65.     _DINT();
  66. //初始化时钟
  67. Init_CLK();
  68.     //所有初始化处理
  69.     nRoom_Mode = 0;
  70.     nSecond = 0;    
  71.     nFlag = 0;
  72.     nidle = 1;
  73.     nCount = 0;
  74.     RingFlag = 1;
  75.     DialogFlag = 1;
  76.     ZhaijiFlag = 0;
  77.     Ring_time = 0;
  78.     Dialog_time = 0;
  79.     nOther_Count = 0;
  80.     AdministratorFlag = 0;
  81.     // 首先初始化系统
  82.     Port_init();     //端口初始化
  83.     Init_TimerB(); 
  84.     
  85. I2C_Initial();
  86.     //从I2C中读出配置信息
  87.     nRoom_Mode = I2C_Read(513);
  88.     Delay();
  89.     Ring_time = I2C_Read(514);
  90.     Delay();
  91.     Dialog_time = I2C_Read(515);
  92.     Delay();
  93.     nFlag = 0x00;
  94. //打开中断
  95. _EINT(); 
  96.      //键盘扫描
  97.     while(1)
  98.     {
  99.      nTemp = 0x14;
  100.         P2OUT = 0x1F;
  101.         
  102. if(nidle == 1) nTemp = Keyscan();   //扫描键盘
  103. switch(nTemp)
  104. {
  105.             case 0:
  106. case 1:
  107. case 2:
  108. case 3:
  109. case 4:
  110. case 5:
  111. case 6:
  112. case 7:
  113. case 8:
  114. case 9:
  115. {
  116.                 switch(nFlag)
  117.                 {
  118.                     case 0x00:
  119.                     { 
  120.                         switch(nCount)
  121.      {
  122.      case 0:
  123.                             {
  124.                              //清除锁存信号
  125.                             STCLK_Lo();
  126. DataOut(nLed[nTemp]);
  127.                                 break;
  128.                             }
  129. case 1:
  130.                             {
  131.                                 DataOut(nLed[nTemp]);
  132.                                 break;
  133.                             }
  134.                     case 2:
  135.                             {
  136.                              DataOut(nLed[nTemp]);
  137.                                 break;
  138.                             }
  139.                          case 3:
  140. {
  141.                                 DataOut(nLed[nTemp]);
  142.                                 break;
  143. }
  144. }//switch(nCount)
  145.                 nResult = 0;
  146.                 nResult = Sub_Process(nTemp,numRoom,nCount,nRoom_Mode);
  147.                 nCount += 1;
  148.                 if(nResult == 1) 
  149. {
  150. //给锁存信号,显示数据
  151.                         STCLK_Hi();
  152.                     Process_Data(numRoom,nCount - 1,nRoom_Mode);
  153.                     nCount = 0;
  154. }
  155.                         break;
  156.                     }//case 0x00:
  157.                     case 0x0a:
  158.                     {
  159.                         nResult = 0;
  160.                         nResult = SetRingTime(nTemp,numRoom,nCount);
  161.                         nCount += 1;
  162.                         if(nResult == 1)
  163.                         {
  164.                             nCount = 0;
  165.                             nFlag = 0x00;
  166.                         }
  167.                         else if(nResult == 2)
  168.                         {
  169. //清除锁存信号
  170. STCLK_Lo();
  171. //输出0
  172. DataOut(nLed[0]);
  173. //给锁存信号,显示数据
  174. STCLK_Hi(); 
  175.                             nCount = 0;
  176.                             nFlag = 0x00;
  177.                         }
  178.                 
  179.                         break;
  180.                     }
  181.                     case 0x0b:
  182.                     {
  183.                         nResult = 0;
  184.                         nResult = SetDialogTime(nTemp,numRoom,nCount);
  185.                         nCount += 1;
  186.                         if(nResult ==1)
  187.                         {
  188.                             nCount = 0;
  189.                             nFlag = 0x00;
  190.                         }
  191.                         else if(nResult == 2)
  192.                         {
  193.                             //清除锁存信号
  194. STCLK_Lo();
  195. //输出0
  196. DataOut(nLed[0]);
  197. //给锁存信号,显示数据
  198. STCLK_Hi(); 
  199.                             nCount = 0;
  200.                             nFlag = 0x00;
  201.                         }
  202.                 
  203.                         break;
  204.                     }
  205.                     case 0x0c:
  206.                     {
  207.                         nResult = 0;
  208.                         nResult = SetMasterPass(nTemp,numRoom,nCount);
  209.                         nCount += 1;
  210.                         if(nResult == 1)
  211.                         {
  212.                             nCount = 0;
  213.                             nFlag = 0x00;
  214.                         }
  215.                         else if(nResult == 2)
  216.                         {
  217.                             //清除锁存信号
  218. STCLK_Lo();
  219. //输出0
  220. DataOut(nLed[0]);
  221. //给锁存信号,显示数据
  222. STCLK_Hi(); 
  223.                             nCount = 0;
  224.                             nFlag = 0x00;
  225.                         } 
  226.                         break;
  227.                     }
  228.                     case 0x0d:
  229.                     {
  230.                         nResult = 0;
  231.                         nResult = OpenDoorSelf(nTemp,numRoom,nCount,nRoom_Mode);
  232.                         nCount += 1;
  233.                 if(nResult == 1) 
  234. {
  235.                     nCount = 0;
  236.                             nFlag = 0x00;
  237. }
  238.                         break;
  239.                     }
  240.                     case 0x12:
  241.                     {
  242.                      nResult = 0;
  243.                      if(AdministratorFlag == 1)
  244.                      {
  245.                          nResult = Administrator(nTemp,numRoom,nCount,nRoom_Mode);
  246.                             nCount += 1;
  247.                     if(nResult == 1) 
  248. {
  249.                         nCount = 0;
  250.                                 nFlag = 0x00;
  251.                                 AdministratorFlag = 0;
  252. }
  253. }
  254.                         break;
  255.                     }
  256.                     case 0x13:
  257.                     {
  258.                         nResult = 0;
  259.                         nResult = SetRoomMode(nTemp,numRoom,nCount);
  260.                         nCount += 1;
  261.                         if(nResult == 1)
  262.                         {
  263.                             nCount = 0;
  264.                             nFlag = 0x00;
  265.                         }
  266.                         else if(nResult == 2)
  267.                         {
  268.                             //清除锁存信号
  269. STCLK_Lo();
  270. //输出0
  271. DataOut(nLed[0]);
  272. //给锁存信号,显示数据
  273. STCLK_Hi(); 
  274.                             nCount = 0;
  275.                             nFlag = 0x00;
  276.                         }
  277.                 
  278.                         break;
  279.                     }                    
  280.                     default:
  281.                         break;
  282.                 }//switch(nFlag)
  283.         break;
  284. }
  285.                         
  286. case 0x0A: // A 用来设置振铃时间
  287. {
  288.      nFlag = 0x0a;
  289. break;
  290. }
  291. case 0x0B: // B 用来设置对话时间
  292. {
  293.      nFlag = 0x0b;
  294. break;
  295. }
  296. case 0x0C: // C 管理员密码设置
  297. {
  298.      nFlag = 0x0c;
  299.      break;
  300. }
  301. case 0x0D: // D 自开锁
  302. {
  303.      //Open_lock();       //密码开锁处理子程序
  304.      nFlag = 0x0d;         //不显示密码
  305.      break;
  306. }
  307. case 0x12: // #
  308.         {
  309.      //Master_init();     //管理员对用户密码初始化处理子程序
  310.      nFlag = 0x12;     
  311.      break;
  312. }
  313. case 0x13: // *
  314. {
  315. //Password_change();     //设置房号模式
  316. nFlag = 0x13;
  317.      break;
  318. }
  319. default:break;
  320. } //键盘扫描结束   
  321.     }         
  322.     return 0;
  323. }
  324. /*********************************************************/
  325. /*   */
  326. /* 中断处理程序    */
  327. /*  */
  328. /*********************************************************/
  329. //定时器B的中断处理
  330. interrupt [TIMERB0_VECTOR] void TimerB_ISR(void)
  331. {
  332. nRing += 1;
  333.     nDialog += 1;
  334. if(nRing >= Ring_time)    //30s
  335. {
  336. nRing = 0;
  337. RingFlag = 0;           //振铃30s中断标志
  338. }
  339. if(nDialog >= Dialog_time)   //60s
  340. {
  341. nDialog = 0;
  342. DialogFlag = 0;      //对话60s中断标志
  343. }
  344. }
  345. //键盘扫描程序模块
  346. /*********************************************************/
  347. /*   */
  348. /* 软件延时子程序    */
  349. /*  */
  350. /*********************************************************/
  351. void Delay(void)
  352. {
  353.     int i;
  354.     for(i = 6553;i > 0;i--) ;
  355. }
  356. //延迟1S
  357. void Delay_1s(void)
  358. {
  359.     int i;
  360.     for(i = 0;i < 100; i++)
  361. for(i = 0;i < 100; i++)
  362.     continue;
  363. }
  364. /*********************************************************/
  365. /*   */
  366. /* 键扫描子程序    */
  367. /*  */
  368. /*********************************************************/
  369. int Keyscan(void)
  370. {
  371.     int nTemp = 0x14;
  372. int nP30;
  373. int nP31;
  374. int nP32;
  375. int nP33;
  376.     while(1)
  377.     {
  378. nP30 = P3IN & BIT0;
  379. nP31 = (P3IN & BIT1) >> 1;
  380. nP32 = (P3IN & BIT1) >> 2;
  381. nP33 = (P3IN & BIT1) >> 3;
  382.         if(nP30 == 1 || nP31 == 1 || nP32 == 1 || nP33 == 1) break;
  383.     }           /*等待有键按下*/
  384.     Delay(); /*软件延时*/
  385.  
  386. nP30 = P3IN & BIT0;
  387. nP31 = (P3IN & BIT1) >> 1;
  388. nP32 = (P3IN & BIT1) >> 2;
  389. nP33 = (P3IN & BIT1) >> 3;
  390.     if(nP30 == 1 || nP31 == 1 || nP32 == 1 || nP33 == 1)
  391. nTemp = KeyServe();      /*如果仍有键按下,则调用键服务子程序*/
  392.     else
  393. nTemp = 0x14;         /*如果为干扰,则令返回值为21*/
  394.     return(nTemp);
  395. }
  396. /*********************************************************/
  397. /*   */
  398. /* 键服务子程序    */
  399. /*  */
  400. /*********************************************************/
  401. int KeyServe(void)
  402. {
  403.     int nTemp = 0x14; 
  404. int nP30;
  405. int nP31;
  406. int nP32;
  407. int nP33;
  408.  
  409.     P2OUT |= BIT0;               /*行线RA0输出为高电平*/
  410. nP30 = P3IN & BIT0;
  411. nP31 = (P3IN & BIT1) >> 1;
  412. nP32 = (P3IN & BIT1) >> 2;
  413. nP33 = (P3IN & BIT1) >> 3;
  414.     if(nP30 == 1) nTemp = 0X13;       /*"*"键*/
  415.     if(nP31 == 1) nTemp = 0X00;       /*"0"键*/
  416.     if(nP32 == 1) nTemp = 0X12;       /*"#"键*/
  417.     if(nP33 == 1) nTemp = 0X0D;       /*"D"键*/
  418.     P2OUT |= BIT1;               /*行线RA1输出为高电平*/
  419. nP30 = P3IN & BIT0;
  420. nP31 = (P3IN & BIT1) >> 1;
  421. nP32 = (P3IN & BIT1) >> 2;
  422. nP33 = (P3IN & BIT1) >> 3;
  423.     if(nP30 == 1) nTemp = 0X07;       /*"7"键*/
  424.     if(nP31 == 1) nTemp = 0X08;       /*"8"键*/
  425.     if(nP32 == 1) nTemp = 0X09;       /*"9"键*/
  426.     if(nP33 == 1) nTemp = 0X0C;       /*"C"键*/
  427.     P2OUT |= BIT2;               /*行线RA2输出为高电平*/
  428. nP30 = P3IN & BIT0;
  429. nP31 = (P3IN & BIT1) >> 1;
  430. nP32 = (P3IN & BIT1) >> 2;
  431. nP33 = (P3IN & BIT1) >> 3;
  432.     if(nP30 == 1) nTemp = 0X04;       /*"4"键*/
  433.     if(nP31 == 1) nTemp = 0X05;       /*"5"键*/
  434.     if(nP32 == 1) nTemp = 0X06;       /*"6"键*/
  435.     if(nP33 == 1) nTemp = 0X0B;       /*"B"键*/
  436. //    P2OUT |= BIT3;               /*行线RA3输出为高电平*/
  437. // nP30 = P3IN & BIT0;
  438. // nP31 = (P3IN & BIT1) >> 1;
  439. // nP32 = (P3IN & BIT1) >> 2;
  440. // nP33 = (P3IN & BIT1) >> 3;
  441. //    if(nP30 == 1) nTemp = 0X01;       /*"1"键*/
  442. //    if(nP31 == 1) nTemp = 0X02;       /*"2"键*/
  443. //    if(nP32 == 1) nTemp = 0X03;       /*"3"键*/
  444. //    if(nP33 == 1) nTemp = 0X0E;       /*"E"键*/
  445.     P2OUT |= BIT4;                /*行线RA4输出为高电平*/
  446. nP30 = P3IN & BIT0;
  447. nP31 = (P3IN & BIT1) >> 1;
  448. nP32 = (P3IN & BIT1) >> 2;
  449. nP33 = (P3IN & BIT1) >> 3;
  450.     if(nP30 == 1) nTemp = 0X01;       /*"1"键*/
  451.     if(nP31 == 1) nTemp = 0X02;       /*"2"键*/
  452.     if(nP32 == 1) nTemp = 0X03;       /*"3"键*/
  453.     if(nP33 == 1) nTemp = 0X0A;       /*"A"键*/
  454.     /*以上根据按下的键确定相应的键值*/
  455.     
  456.     while(1)
  457.     {
  458. nP30 = P3IN & BIT0;
  459.     nP31 = (P3IN & BIT1) >> 1;
  460.     nP32 = (P3IN & BIT1) >> 2;
  461.     nP33 = (P3IN & BIT1) >> 3;
  462.      if((nP30 == 0) && (nP31 == 0) && (nP32 == 0) && (nP33 == 0)) 
  463. break;/*等待键盘松开*/
  464.     }
  465.     return(nTemp);
  466. }
  467. void Port_init(void)
  468. {
  469. //将P2口所有的管脚设置为一般I/O口
  470.     P2SEL = 0;
  471.     //P2.0~P2.4为输出方向
  472. P2DIR = 0x00;
  473. P2DIR |= BIT0;
  474. P2DIR |= BIT1;
  475. P2DIR |= BIT2;
  476. P2DIR |= BIT3;
  477. P2DIR |= BIT4;
  478. //将P1口所有的管脚在初始化的时候设置为输入方式
  479.     P1DIR = 0;
  480.     //将P1口所有的管脚设置为一般I/O口
  481.     P1SEL = 0;
  482.     // 将P1.0 P1.1 P1.2 设置为输出方向
  483.     P1DIR |= BIT0;
  484.     P1DIR |= BIT1;
  485. P1DIR |= BIT2;
  486. //将P3口所有的管脚在初始化的时候设置为输入方式
  487.     P3DIR = 0;
  488. //将P4口所有的管脚在初始化的时候设置为输入方式
  489.     P4DIR = 0;
  490. //P4.0~P4.4为输出方向
  491. P4DIR = 0x00;
  492. P4DIR |= BIT0;
  493. P4DIR |= BIT1;
  494. P4DIR |= BIT2;
  495. P4DIR |= BIT3;
  496. P4DIR |= BIT4;
  497. }
  498. void Init_TimerB(void)
  499. {
  500. // 选择ACLK,清除TAR
  501.     TBCTL = TBSSEL0 + TBCLR;
  502. // TBCCR0 中断允许
  503.     TBCCTL0 = CCIE;         
  504. // 时间间隔为 1 s
  505.     TBCCR0 = 32768;   
  506.     // 增记数模式
  507.     TBCTL |= MC0; 
  508. return;
  509. }
  510. void Send_Bit1(void)
  511. {
  512.     char i;
  513. P4OUT &= ~(BIT4);
  514.     for(i = 55;i > 0;i--) ;
  515.     for(i = 55;i > 0;i--) ;
  516. P4OUT |= BIT4;
  517.     for(i = 55;i > 0;i--) ;
  518. }
  519. void Send_Bit0(void)
  520. {
  521.     char i;
  522.     P4OUT &= ~(BIT4);
  523.     for(i = 55;i > 0;i--) ;
  524.     P4OUT |= BIT4;
  525.     for(i = 55;i > 0;i--) ;
  526.     for(i = 55;i > 0;i--) ;
  527. }
  528. void Send_Pre(void)
  529. {
  530.     char i,j;
  531.     
  532.     P4OUT &= ~(BIT4);
  533.     for(j = 0;j < 36;j++)
  534.         for(i = 0;i < 55;i++)
  535.             ;
  536.     P4OUT |= BIT4;
  537.     for(i = 55; i > 0;i--) ;
  538. }
  539. //发送编码数据
  540. void Send_data(unsigned int numCode)  //要发送的数据是numCode
  541. {
  542.     int CodeBit; 
  543.     int SendBit;
  544.     int nHigh;
  545.     int nLow;
  546.     int n;
  547.     int i;
  548.         
  549.     nLow = numCode & 0x0f;
  550.     nHigh = numCode >> 4;
  551.         
  552.     Send_Pre();
  553.     for(i = 0;i < 8;i++)
  554.     {
  555.         SendBit = nHigh & 0x01;
  556.         if(SendBit == 1)
  557.             Send_Bit1();
  558.         else
  559.             Send_Bit0();                           
  560.         nHigh >>= 1;
  561.     }
  562.     for(i = 0;i < 4;i++)
  563.     {
  564.         SendBit = nLow & 0x01;
  565.         if(SendBit == 1)
  566.             Send_Bit1();
  567.         else
  568.             Send_Bit0();                          
  569.         nLow >>= 1;
  570.     }       
  571. }
  572. //振铃处理子程序模块
  573. //RE1脚发出1/450Hz的脉冲
  574. void Ring(void) 
  575. {
  576.     int i;
  577. P4OUT &= ~(BIT4);
  578. P4OUT &= ~(BIT0);
  579.     P4OUT |= BIT2;
  580.     for(i = 0; i < 200;i++) ;
  581.     P4OUT &= ~(BIT2);
  582.     for(i = 0; i < 200;i++);
  583. }
  584. //拨号处理子程序
  585. void DialAndProcess(void)
  586. {
  587.     int i;
  588. int nBit5;
  589. int nBit6;
  590.     //判断选通房间分机是否存在
  591.     Delay();
  592.     Delay();
  593.     Delay();
  594. nBit5 = (P1IN & BIT5) >> 5;
  595. nBit6 = (P1IN & BIT6) >> 6;
  596.     if((nBit6 == 1) && (nBit5 == 0))   
  597.     {
  598. //分机存在
  599.         //清除锁存信号
  600.     STCLK_Lo();
  601.     //输出1
  602.     DataOut(nLed[1]);
  603.     //给锁存信号,显示数据
  604.     STCLK_Hi();
  605. //判断分机是否短路
  606. nBit5 = (P1IN & BIT5) >> 5;
  607.     nBit6 = (P1IN & BIT6) >> 6;
  608.         if((nBit6 == 1) && (nBit5 == 1))   
  609. {
  610. //分机短路
  611. //提示音三次
  612. Ring();
  613. P4OUT &= ~(BIT2);
  614. Delay_1s();
  615. Ring();
  616. P4OUT &= ~(BIT2);
  617. Delay_1s();
  618. Ring();
  619. Delay_1s();
  620. P4OUT &= ~(BIT2);
  621. }//分机短路
  622. else   
  623. {
  624. //分机不短路
  625. //发出振铃信号
  626. //初始化摘机标志,为0代表没有摘机
  627. ZhaijiFlag = 0;   
  628. //定时器中断允许
  629. TBCTL |= TBCLR;
  630. TBCCTL0 |= CCIE; 
  631. //在振铃时间30s内
  632. while(RingFlag)  
  633. {
  634. //发出振铃信号
  635. Ring();   
  636. Delay_1s();
  637. P4OUT &= ~(BIT2);
  638. //判断分机是否摘机
  639. nBit5 = (P1IN & BIT5) >> 5;
  640.             nBit6 = (P1IN & BIT6) >> 6;
  641.                 if((nBit6 == 0) && (nBit5 == 0)) 
  642. {
  643. //分机摘机
  644. //摘机标志为1,代表摘机
  645. ZhaijiFlag = 1;    
  646. }//分机摘机
  647. if(ZhaijiFlag == 1) break;   
  648. }//振铃时间内
  649. //定时器中断禁止
  650. TBCCTL0 &= ~(CCIE);  
  651. //假如分机摘机
  652. if(ZhaijiFlag == 1)    
  653. {
  654. //分机摘机
  655. //对话
  656. //定时器中断允许
  657. TBCTL |= TBCLR;
  658. TBCCTL0 |= CCIE; 
  659. P4OUT &= ~(BIT2);
  660. DialogFlag = 1;
  661. //在对话时间60s内
  662. while( DialogFlag)   
  663. {
  664. //打开对讲
  665. P4OUT |= BIT0;
  666. P4OUT |= BIT1;
  667. P4OUT &= ~(BIT2);
  668. P4OUT &= ~(BIT4);
  669. //判断分机是否挂机
  670. nBit5 = (P1IN & BIT5) >> 5;
  671.                 nBit6 = (P1IN & BIT6) >> 6;
  672.                     if((nBit6 == 0) && (nBit5 == 0))  
  673. //分机挂机
  674. //关闭对讲
  675. P4OUT &= ~(BIT0);
  676. P4OUT &= ~(BIT3);
  677. }//分机挂机,返回
  678. else  
  679. {
  680. //分机没有挂机
  681. //判断是否开锁
  682. nBit5 = (P1IN & BIT5) >> 5;
  683.                     nBit6 = (P1IN & BIT6) >> 6;
  684.                         if((nBit6 == 1) && (nBit5 == 1)) 
  685. {
  686. //分机开锁
  687. for(i = 0;i < 10;i++)
  688. {
  689. //开电锁命令
  690. P4OUT &= ~(BIT1);
  691. }
  692. break;
  693. }//分机开锁
  694. else//不开锁
  695. {
  696. ;                        
  697. }//不开锁 
  698. }//分机没有挂机
  699. }//对话时间内
  700. //定时器中断禁止
  701. TBCCTL0 &= ~(CCIE);       
  702. }//分机摘机
  703. }//分机不短路
  704.     }//分机存在
  705.     else    //分机不存在
  706.     {
  707. //清除锁存信号
  708.     STCLK_Lo();
  709.     //输出0
  710.     DataOut(nLed[0]);
  711.     //给锁存信号,显示数据
  712.     STCLK_Hi();        
  713.         //提示音两次
  714. Ring();
  715. Delay_1s();
  716. Ring();
  717.     }
  718.     nidle = 1;   //重新开始扫描键盘
  719. }   
  720. int Process_Data(char nIn[],int nLen,char nRoom_Mode)
  721. {
  722.     unsigned int nTemp = 0;
  723.     int i;
  724.     // 第一,进行编码,获得编码数据
  725.     switch(nRoom_Mode)
  726.     {
  727.      case 1://房间范围在011-994,每层4户。
  728.      {
  729.          nTemp = nIn[0] * 256 + nIn[1] * 16 + nIn[2];
  730.          if(nIn[2] == 3) nTemp += 1;
  731.          else if(nIn[2] == 4) nTemp += 4;
  732.          break;
  733.      }
  734.      case 2:
  735.      {
  736.          
  737.          break;
  738.      }
  739.      case 3:
  740.      {
  741.          
  742.          break;
  743.      }
  744.      case 4:
  745.      {
  746.          
  747.          break;
  748.      }
  749.      case 5:
  750.      {
  751.          
  752.          break;
  753.      }
  754.      case 6:
  755.      {
  756.          
  757.          break;
  758.         }
  759.         case 7:
  760.         {
  761.             
  762.             break;
  763.         }
  764.      case 8:
  765.      {
  766.          
  767.          break;
  768.      }
  769.      case 9:
  770.      {
  771.          
  772.          break;
  773.      }
  774.      default:break;
  775.     }
  776.     // 第二,进行编码数据传送
  777.     for(i = 0;i < 5;i++) Send_data(nTemp);
  778.     // 第三,进行拨号以及相应处理
  779.     for(i = 0;i < 5;i++) DialAndProcess();
  780.     return 0;
  781. }
  782. char Sub_Process(char nTemp,char nIn[],int nLen,char nRoom_Mode)
  783. {
  784.     char chrTemp = 0;
  785.     nIn[nLen] = nTemp;
  786.     switch(nRoom_Mode)
  787.     {
  788.      case 1:
  789.      {
  790.          if(nLen >= 2) chrTemp = 1;
  791.          else chrTemp = 0;
  792.          break;
  793.      }
  794.      case 2:
  795.      {
  796.          if(nLen >= 2) chrTemp = 1;
  797.          else chrTemp = 0;
  798.          break;
  799.      }
  800.      case 3:
  801.      {
  802.          if(nLen >= 2) chrTemp = 1;
  803.          else chrTemp = 0;
  804.          break;
  805.      }
  806.      case 4:
  807.      {
  808.          
  809.          break;
  810.      }
  811.      case 5:
  812.      {
  813.          
  814.          break;
  815.      }
  816.      case 6:
  817.      {
  818.          if(nLen >= 3) chrTemp = 1;
  819.          else chrTemp = 0;
  820.          break;
  821.         }
  822.         case 7:
  823.         {
  824.             if(nLen >= 3) chrTemp = 1;
  825.             else chrTemp = 0;
  826.             break;
  827.         }
  828.      case 8:
  829.      {
  830.          if(nLen >= 3) chrTemp = 1;
  831.          else chrTemp = 0;
  832.          break;
  833.      }
  834.      case 9:
  835.      {
  836.          if(nLen >= 1) chrTemp = 1;
  837.          else chrTemp = 0;
  838.          break;
  839.      }
  840.      default:
  841.      {
  842.          chrTemp = 0;
  843.          break;
  844.      }
  845.     }
  846.     
  847.     return chrTemp;
  848. }
  849. char OpenDoorSelf(char nTemp,char nIn[],int nLen,char nRoom_Mode)
  850. {
  851.     unsigned int nAddr;
  852.     char nValue[4];
  853.     char chrTemp = 0;
  854.     nIn[nLen] = nTemp;
  855.     switch(nRoom_Mode)
  856.     {
  857.      case 1:
  858.      {
  859.          if(nLen >= 6) 
  860.          {
  861.           chrTemp = 1;
  862.           nAddr = ((nIn[0] * 10 + nIn[1] - 1) * 4 + nIn[2]) * 2;
  863.           nValue[0] = I2C_Read(nAddr);
  864.           Delay();
  865.           nAddr += 1;
  866.           nValue[1] = I2C_Read(nAddr);
  867.           Delay();
  868.           nValue[2] = nIn[3] * 16 + nIn[4];
  869.           nValue[3] = nIn[5] * 16 + nIn[6];
  870.           if((nValue[0] == nValue[2]) && (nValue[1] == nValue[3]))
  871.           {
  872.               //Dialog
  873. P4OUT &= ~(BIT0);
  874.                     //un_lock
  875. P4OUT &=~(BIT1);
  876.                     //code
  877. P4OUT &= ~(BIT4);
  878.                     //Ring
  879. P4OUT &= ~(BIT2);
  880.                 }
  881.                 else
  882.                 {
  883.                  //提示音三次
  884.                Ring();
  885.                    P4OUT &= ~(BIT2);
  886.                Delay_1s();
  887.                    Ring();
  888.                    P4OUT &= ~(BIT2);
  889.                Delay_1s();
  890.                Ring();
  891.                    Delay_1s();
  892.                    P4OUT &= ~(BIT2);
  893.                 }                
  894.          }
  895.          else chrTemp = 0;
  896.          break;
  897.      }
  898.      case 2:
  899.      {
  900.          if(nLen >= 6) 
  901.          {
  902.           chrTemp = 1;
  903.          }
  904.          else chrTemp = 0;
  905.          break;
  906.      }
  907.      case 3:
  908.      {
  909.          if(nLen >= 6) 
  910.          {
  911.           chrTemp = 1;
  912.          }
  913.          else chrTemp = 0;
  914.          break;
  915.      }
  916.      case 4:
  917.      {
  918.          
  919.          break;
  920.      }
  921.      case 5:
  922.      {
  923.          
  924.          break;
  925.      }
  926.      case 6:
  927.      {
  928.          if(nLen >= 7) 
  929.          {
  930.           chrTemp = 1;
  931.          }
  932.          else chrTemp = 0;
  933.          break;
  934.         }
  935.         case 7:
  936.         {
  937.             if(nLen >= 7) 
  938.             {
  939.              chrTemp = 1;
  940.             }
  941.             else chrTemp = 0;
  942.             break;
  943.         }
  944.      case 8:
  945.      {
  946.          if(nLen >= 7) 
  947.          {
  948.           chrTemp = 1;
  949.          }
  950.          else chrTemp = 0;
  951.          break;
  952.      }
  953.      case 9:
  954.      {
  955.          if(nLen >= 5) 
  956.          {
  957.           chrTemp = 1;
  958.          }
  959.          else chrTemp = 0;
  960.          break;
  961.      }
  962.      default:
  963.      {
  964.          chrTemp = 0;
  965.          break;
  966.      }
  967.     }
  968.     
  969.     return chrTemp;
  970. }
  971. char Administrator(char nTemp,char nIn[],int nLen,char nRoom_Mode)
  972. {
  973.     unsigned int nAddr;
  974.     unsigned char nValue[2];
  975.     char chrTemp = 0;
  976.     nIn[nLen] = nTemp;
  977.     switch(nRoom_Mode)
  978.     {
  979.      case 1:
  980.      {
  981.          if(nLen >= 6) 
  982.          {
  983.           nAddr = ((nIn[0] * 10 + nIn[1] - 1) * 4 + nIn[2]) * 2;
  984.           nValue[0] = nIn[3] * 16 + nIn[4];
  985.           I2C_Write(nAddr,nValue[0]);
  986.           Delay();
  987.           nAddr += 1;
  988.           nValue[1] = nIn[5] * 16 + nIn[6];
  989.           I2C_Write(nAddr,nValue[1]);
  990.           Delay();
  991.           chrTemp = 1;
  992.          }
  993.          else chrTemp = 0;
  994.          break;
  995.      }
  996.      case 2:
  997.      {
  998.          if(nLen >= 6) 
  999.          {
  1000.           chrTemp = 1;
  1001.          }
  1002.          else chrTemp = 0;
  1003.          break;
  1004.      }
  1005.      case 3:
  1006.      {
  1007.          if(nLen >= 6) 
  1008.          {
  1009.           chrTemp = 1;
  1010.          }
  1011.          else chrTemp = 0;
  1012.          break;
  1013.      }
  1014.      case 4:
  1015.      {
  1016.          
  1017.          break;
  1018.      }
  1019.      case 5:
  1020.      {
  1021.          
  1022.          break;
  1023.      }
  1024.      case 6:
  1025.      {
  1026.          if(nLen >= 7) 
  1027.          {
  1028.           chrTemp = 1;
  1029.          }
  1030.          else chrTemp = 0;
  1031.          break;
  1032.         }
  1033.         case 7:
  1034.         {
  1035.             if(nLen >= 7) 
  1036.             {
  1037.              chrTemp = 1;
  1038.             }
  1039.             else chrTemp = 0;
  1040.             break;
  1041.         }
  1042.      case 8:
  1043.      {
  1044.          if(nLen >= 7) 
  1045.          {
  1046.           chrTemp = 1;
  1047.          }
  1048.          else chrTemp = 0;
  1049.          break;
  1050.      }
  1051.      case 9:
  1052.      {
  1053.          if(nLen >= 5) 
  1054.          {
  1055.           chrTemp = 1;
  1056.          }
  1057.          else chrTemp = 0;
  1058.          break;
  1059.      }
  1060.      default:
  1061.      {
  1062.          chrTemp = 0;
  1063.          break;
  1064.      }
  1065.     }
  1066.     
  1067.     return chrTemp;
  1068. }
  1069. char SetRoomMode(char nTemp,char nIn[],int nLen)//管理员设置房号模式
  1070. {
  1071.     unsigned char nRoom_Mode;
  1072.     unsigned char nValue[4];
  1073.     char chrTemp = 0;
  1074.     
  1075.     nIn[nLen] = nTemp;
  1076.     
  1077.     if(nLen >= 4) 
  1078.     {
  1079.      chrTemp = 1;
  1080.      nValue[0] = nIn[0] * 16 + nIn[1];
  1081.      nValue[1] = nIn[2] * 16 + nIn[3];
  1082.      nValue[2] = I2C_Read(0);
  1083.      Delay();
  1084.      nValue[3] = I2C_Read(1);
  1085.      Delay();
  1086.      if((nValue[0] == nValue[2]) && (nValue[1] == nValue[3]))
  1087.      {
  1088.          nRoom_Mode = nIn[4];
  1089.          if(nRoom_Mode > 9) chrTemp = 2;
  1090.          else I2C_Write(513,nRoom_Mode);
  1091.          Delay();
  1092.      }
  1093.      else chrTemp = 2;
  1094.     }
  1095.     else chrTemp = 0;
  1096.     return chrTemp;
  1097. }
  1098. char SetRingTime(char nTemp,char nIn[],int nLen)//管理员设置振铃时间
  1099. {
  1100.     unsigned char nRing_Time;
  1101.     unsigned char nValue[4];
  1102.     char chrTemp = 0;
  1103.     
  1104.     nIn[nLen] = nTemp;
  1105.     
  1106.     if(nLen >= 5) 
  1107.     {
  1108.      chrTemp = 1;
  1109.      nValue[0] = nIn[0] * 16 + nIn[1];
  1110.      nValue[1] = nIn[2] * 16 + nIn[3];
  1111.      nValue[2] = I2C_Read(0);
  1112.      Delay();
  1113.      nValue[3] = I2C_Read(1);
  1114.      if((nValue[0] == nValue[2]) && (nValue[1] == nValue[3]))
  1115.      {
  1116.          nRing_Time = nIn[4] * 16 + nIn[5];
  1117.          I2C_Write(514,nRing_Time);
  1118.      }
  1119.      else chrTemp = 2;
  1120.     }
  1121.     else chrTemp = 0;
  1122.     return chrTemp;
  1123. }
  1124. char SetDialogTime(char nTemp,char nIn[],int nLen)//管理员设置对话时间
  1125. {
  1126.     unsigned char nDialog_Time;
  1127.     unsigned char nValue[4];
  1128.     char chrTemp = 0;
  1129.     
  1130.     nIn[nLen] = nTemp;
  1131.     
  1132.     if(nLen >= 5) 
  1133.     {
  1134.      chrTemp = 1;
  1135.      nValue[0] = nIn[0] * 16 + nIn[1];
  1136.      nValue[1] = nIn[2] * 16 + nIn[3];
  1137.      nValue[2] = I2C_Read(0);
  1138.      Delay();
  1139.      nValue[3] = I2C_Read(1);
  1140.      if((nValue[0] == nValue[2]) && (nValue[1] == nValue[3]))
  1141.      {
  1142.          nDialog_Time = nIn[4] * 16 + nIn[5];
  1143.          I2C_Write(515,nDialog_Time);
  1144.      }
  1145.      else chrTemp = 2;
  1146.     }
  1147.     else chrTemp = 0;
  1148.     return chrTemp;
  1149. }
  1150. char SetMasterPass(char nTemp,char nIn[],int nLen)
  1151. {
  1152.     unsigned char nNum;
  1153.     unsigned char nValue[6];
  1154.     char chrTemp = 0;
  1155.     
  1156.     nIn[nLen] = nTemp;
  1157.     
  1158.     if(nLen >= 7) 
  1159.     {
  1160.      chrTemp = 1;
  1161.      //输入的新密码
  1162.      nValue[0] = nIn[4] * 16 + nIn[5];
  1163.      nValue[1] = nIn[6] * 16 + nIn[7];
  1164.      //以前的密码,如果为第一次设置时,密码为1111
  1165.      nValue[4] = nIn[0] * 16 + nIn[1];
  1166.      nValue[5] = nIn[2] * 16 + nIn[3];
  1167.     
  1168.      nValue[2] = I2C_Read(0);
  1169.      Delay();
  1170.      nValue[3] = I2C_Read(1);
  1171.     
  1172.      if((nValue[2] == 0xff) && (nValue[3] == 0xff))//第一次设置密码
  1173.      {
  1174.         if((nValue[4] == 0x11) && (nValue[5] == 0x11))
  1175.         {
  1176.             //写入新密码
  1177.             I2C_Write(0,nValue[0]);
  1178.             Delay();
  1179.             I2C_Write(1,nValue[1]);
  1180.             chrTemp = 1;
  1181.         }
  1182.         else
  1183.         {
  1184.             chrTemp = 2;
  1185.         }    
  1186.      }
  1187.      else//不是第一次设置密码
  1188.      {
  1189.          if((nValue[4] == nValue[2]) && (nValue[5] == nValue[3]))//与以前的久密码进行比较,确定是否是管理员
  1190.          {
  1191.           //写入新密码
  1192.             I2C_Write(0,nValue[0]);
  1193.             Delay();
  1194.             I2C_Write(1,nValue[1]);
  1195.             chrTemp = 1;
  1196.          }
  1197.          else
  1198.          {
  1199.           chrTemp = 2;
  1200.          }
  1201.          //进入管理员设置用户密码模式
  1202.          if((nValue[4] == nValue[0]) && (nValue[5] == nValue[1])) AdministratorFlag = 1;
  1203.      }
  1204.     }
  1205.     else chrTemp = 0;
  1206.     return chrTemp;
  1207. }