標題: M8單片機串口通訊監(jiān)聽(使用PROTEUS串口仿真GSM模塊AT指令通訊)源碼 [打印本頁]
作者: feijihuran    時間: 2018-3-19 16:35
標題: M8單片機串口通訊監(jiān)聽(使用PROTEUS串口仿真GSM模塊AT指令通訊)源碼
實現(xiàn)監(jiān)聽(使用PROTEUS串口例子)V1.0
M8單片機仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）：


全部資料51hei下載地址：
竊聽器(使用PROTEUS串口例子)V1.0.zip (123.24 KB, 下載次數(shù): 67)



單片機源程序如下:
  1. ////////////////////////////////////////////////////////////////////////////////
  2. // ICC-AVR application builder : 6-25 下午 06:02:39
  3. // Target : M8
  4. // Crystal: 3.6864Mhz
  5. // Author:  Anwarye
  6. // Title:   Detcetaphone
  7. ////////////////////////////////////////////////////////////////////////////////

  9. #include <iom8v.h>
  10. #include <macros.h>
  11. #include "var.h"

  13. #define XTAL == 3.6864M

  15. ////////////////////////////////////////////////////////////////////////////////
  16. #pragma interrupt_handler uart0_rx_isr:12
  17. void uart0_rx_isr(void)
  18. {
  19.     unsigned char i,j;
  20.     if(UDR == 0x0A)
  21.     {
  22.        return;                 // 收到0x0A直接丟棄
  23.     }
  24.         
  25.         i = RxIndex;
  26.         j = RxIndex-1;
  27.     if((RxBuf[0] == 0x30) && (RxBuf[1] == 0x0D))
  28.     {
  29.         RxIndexTail = RxIndex;              // 保存接收緩沖指針尾
  30.         RxIndex = 0;                                                   // 接收緩沖指針歸零
  31.             RxStatus = 1;                                                // 接收完成標志置位
  32.                 OkFlag = 1;
  33.                 error = 0;
  34.                 return;
  35.         }
  36.     if((RxBuf[0] == 0x32) && (RxBuf[1] == 0x0D))  // 收到來電信號，來電標志置位
  37.     {
  38.         CallInFlag = 1;                            // 置電話呼入標志
  39.             RxIndex = 0;
  40.                 RxStatus = 1;
  41.                 OkFlag = 1;
  42.                 return;  
  43.     }
  44.     else if((RxBuf[0] == 0x33) && (RxBuf[1] == 0x0D))  // 被叫號碼忙 或者掛機 主叫掛機
  45.     {
  46.         BusyFlag = 1;                                       // 置電話呼入標志
  47.             RxIndex = 0;
  48.                 RxStatus = 1;
  49.                 OkFlag = 1;
  50.                 return;  
  51.     }      
  52.     else if((RxBuf[0] == 0x37) && (RxBuf[1] == 0x0D))  // 收到來電信號，來電標志置位
  53.     {
  54.         NoCarrierFlag = 1;                                   // 置電話呼入標志  NO CARRIER
  55.             RxIndex = 0;
  56.                 RxStatus = 1;
  57.                 OkFlag = 1;
  58.                 return;
  59.     }
  60.     else if((RxBuf[0] == 0x34) && (RxBuf[1] == 0x0D))  // 收到來電信號，來電標志置位
  61.     {
  62.             RxIndex = 0;
  63.                 RxStatus = 1;
  64.                 OkFlag = 1;
  65.                 error = 1;
  66.                 return;        
  67.         }
  68.         else
  69.     {
  70.    
  71.     RxBuf[RxIndex++] = UDR;                 // 繼續(xù)接收數(shù)據(jù)放入接收緩沖
  72.         RxStatus = 0;                         // 串口接收中
  73. //        return;                                                                     // 結(jié)束接收，直接跳出
  74.         }
  75. }

  77. ////////////////////////////////////////////////////////////////////////////////
  78. #pragma interrupt_handler uart0_tx_isr:14
  79. void uart0_tx_isr(void)
  80. {
  81.    
  82.     if(!TxStatus)                                   // 本幀數(shù)據(jù)未發(fā)完，則繼續(xù)發(fā)送  
  83.         {
  84.             //while ( !(UCSRA & (1<<UDRE)) );             // 等待UDR空
  85.             UDR = TxBuf[TxIndex];               
  86.         }
  87.         if((TxBuf[TxIndex] == 0x0D) || (TxBuf[TxIndex] == 0x1A))  // 本幀數(shù)據(jù)發(fā)送結(jié)束
  88.         {
  89.                 TxStatus = 1;                          // 發(fā)送完成狀態(tài)標志置位
  90.                 TxIndex = 0;                           // 發(fā)送緩沖區(qū)指針歸零
  91.                 UCSRB &= ~((1<<TXCIE));//|(1<<TXEN));  // 關(guān)發(fā)送中斷
  92.                 return;
  93.         }
  94.         TxIndex++;                              
  95. }
  96. unsigned char CheckRx(void)
  97. {
  98.     unsigned char i,j;
  99.         i = RxIndex;
  100.         j = RxIndex - 1;
  101.     if(( RxBuf[j] == 0x30) && (RxBuf[i] == 0x0D))
  102.         {
  103.             RxIndex = 0;
  104.                 return (1);
  105.         }
  106.         else
  107.         {
  108.             return (0);
  109.         }
  110. }
  111. /*-----------------------------------------------------------------------*/
  112. ///////////////////////////  清除接收緩沖  ////////////////////////////////
  113. /*-----------------------------------------------------------------------*/
  114. void ClearRxBuf(void)
  115. {
  116.     unsigned char i;
  117.         for(i=0;i<128;i++)
  118.         {
  119.             RxBuf[i] = 0;
  120.         }
  121. }
  122. /*-----------------------------------------------------------------------*/
  123. ///////////////////////////  串口發(fā)送使能  ////////////////////////////////
  124. /*-----------------------------------------------------------------------*/
  125. void TxEnable(void)
  126. {
  127.     //RxIndex = 0;
  128.     UDR = TxBuf[0];                            // 發(fā)送緩沖頭送入串口發(fā)送寄存器，激活開始發(fā)送
  129.         UCSRB |= ((1<<TXCIE));//|(1<<TXEN));
  130. }
  131. /*-----------------------------------------------------------------------*/
  132. /////////////////////////////  發(fā)送AT命令 /////////////////////////////////
  133. /*-----------------------------------------------------------------------*/
  134. void Put_AT_command(const unsigned char *atc, unsigned char atlen)
  135. {
  136.     unsigned char count;
  137.         
  138.         for(count = 0;count < atlen;count++)      // AT命令竄移入發(fā)送緩沖
  139.         {
  140.             TxBuf[count] = atc[count];
  141.         }
  142.         
  143.         TxBuf[atlen] = 0x0D;                      // 發(fā)送緩沖竄結(jié)尾加“回車”
  144.         TxBuf[atlen + 1] = 0x00;                  // 發(fā)送緩沖竄結(jié)束符號

  146.         OkFlag = 0;
  147.     TxStatus = 0;
  148.         TxIndex = 1;                              // 發(fā)送指針偏移1
  149.         TxEnable();                               // 激活發(fā)送
  150.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  151.         DelayMs(20);
  152.         while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束
  153.         OkFlag = 0;

  155. }

  157. /*-----------------------------------------------------------------------*/
  158. /////////////////////////  從內(nèi)存發(fā)送AT命令串  ////////////////////////////
  159. /*-----------------------------------------------------------------------*/
  160. void Put_AT_String(unsigned char *atc, unsigned char atlen)
  161. {
  162.     unsigned char count;
  163.                
  164.         for(count = 0;count < atlen;count++)
  165.         {
  166.             TxBuf[count] = *(atc+count);
  167.         }
  168.         
  169.         TxBuf[atlen] = 0x0D;                      // 發(fā)送緩沖竄結(jié)尾加“回車”
  170.         TxBuf[atlen + 1] = 0x00;                  // 發(fā)送緩沖竄結(jié)束符號

  172.     OkFlag = 0;
  173.     TxStatus = 0;
  174.         TxIndex = 1;                              // 發(fā)送指針偏移1
  175.         TxEnable();                               // 激活發(fā)送
  176.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  177.         DelayMs(20);
  178.         while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束
  179.         OkFlag = 0;
  180. }
  181. /*-----------------------------------------------------------------------*/
  182. /////////////////////////  向串口發(fā)送一串數(shù)據(jù)  ////////////////////////////
  183. /*-----------------------------------------------------------------------*/
  184. void PutString(unsigned char *str, unsigned char length,unsigned char retflag)
  185. {
  186.     unsigned char count;

  188.         for(count = 0;count < length;count++)
  189.         {
  190.             TxBuf[count] = *(str+count);
  191.         }
  192.         
  193.         TxBuf[length] = 0x0D;                     // 發(fā)送緩沖竄結(jié)尾加“回車”
  194.         TxBuf[length+ 1] = 0x00;                  // 發(fā)送緩沖竄結(jié)束符號
  195.         
  196.     TxStatus = 0;
  197.         TxIndex = 1;                              // 發(fā)送指針偏移1
  198.         OkFlag = 0;
  199.         TxEnable();
  200.                                                   // 激活發(fā)送
  201.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  202.         DelayMs(20);
  203.     if(retflag)
  204.     {        
  205.         while(!OkFlag);                       // 收到模塊返回OK,命令結(jié)束
  206.                 OkFlag = 0;
  207.         }
  208.         else
  209.         {
  210.         DelayMs(200);
  211.                 OkFlag = 0;
  212.         }
  213. }
  214. ////////////////////////////////////////////////////////////////////////////////

  216. /*-----------------------------------------------------------------------*/
  217. //////////////////////////         撥號         ///////////////////////////
  218. /*-----------------------------------------------------------------------*/
  219. void DialNum(void)
  220. {
  221.     unsigned char i,count=0,length=0;

  223.         while ((PhoneNum[count++] != 0))                  // 計算電話號碼長度
  224.         {
  225.             length++;
  226.         }
  227.         
  228.         TxBuf[0] = 'A';
  229.         TxBuf[1] = 'T';
  230.         TxBuf[2] = 'D';
  231.         
  232.         i = 3;
  233.     for(count=0;count<length;count++)
  234.         {
  235.             TxBuf[i++] = PhoneNum[count];
  236.         }
  237.    
  238.         TxBuf[length+3] = ';';
  239.         TxBuf[length+4] = 0x0D;
  240.         
  241.     OkFlag = 0;
  242.     TxStatus = 0;
  243.         TxIndex = 1;                              // 發(fā)送指針偏移1
  244.         TxEnable();                               // 激活發(fā)送
  245.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  246.         DelayMs(20);
  247.         //while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束        
  248.     OkFlag = 0;
  249. }

  251. /*-----------------------------------------------------------------------*/
  252. /////////////////////////////  比較兩個串 /////////////////////////////////
  253. /*-----------------------------------------------------------------------*/
  254. unsigned char StringCompare(volatile unsigned char *str1,const unsigned char *str2,unsigned char strlen)
  255. {
  256.     while(strlen--)
  257.         {
  258.             if(*str1++ != *str2++) return(FALSE);    // 兩個串不相等返回假
  259.         }
  260.         return(TRUE);
  261. }

  263. /*-----------------------------------------------------------------------*/
  264. /////////////////////////////    刪除短信    //////////////////////////////
  265. /*-----------------------------------------------------------------------*/
  266. void Delete_SMS(unsigned char num)     // 刪除SMS，=0刪除所有SMS
  267. {
  268.     unsigned char count;

  270.         for(count = 0;count < AtcmgdLen;count++)      // AT命令竄移入發(fā)送緩沖
  271.         {
  272.             TmpBuf[count] = Atcmgd[count];
  273.         }
  274.                
  275.         if(num == ALL)
  276.         {
  277.            for(count = 1; count < 10; count++)
  278.            {
  279.                TmpBuf[AtcmgdLen] = count + 0x30;
  280.                Put_AT_String((unsigned char*)TmpBuf,(AtcmgdLen+1));

  282.                 }
  283.            TmpBuf[AtcmgdLen] = 0x31;
  284.        for(count = 0; count < 10; count++)
  285.            {
  286.                TmpBuf[AtcmgdLen+1] = count + 0x30;
  287.                Put_AT_String((unsigned char*)TmpBuf,(AtcmgdLen+2));

  289.             }

  291.         }
  292.         else
  293.         {
  294.             TmpBuf[AtcmgdLen] = num + 0x30;
  295.             Put_AT_String((unsigned char*)TmpBuf,(AtcmgdLen+1));

  297.         }
  298. }

  300. /*-----------------------------------------------------------------------*/
  301. ///////////////////////////  檢查SMS返回  //////////////////////////////
  302. /*-----------------------------------------------------------------------*/
  303. unsigned char CheckSMS_in(void)
  304. {
  305.         while(!RxStatus);                            // 等待接收完成
  306.         DelayMs(100);

  308.         if(StringCompare(RxBuf,SMSin,SMSinLen))      // 如果收到OK完成    +CMTI: "SM", 1
  309.         {
  310.                 return (OK);
  311.         }
  312.         else
  313.         {
  314.             return (ERROR);
  315.         }

  317. }
  318. /*-----------------------------------------------------------------------*/
  319. ///////////////              將設(shè)置號碼存入內(nèi)存           /////////////////
  320. /*-----------------------------------------------------------------------*/
  321. void CheckSMS(void)
  322. {
  323.     unsigned char i=0,j=0,index,numlen=0;
  324.         for(;i<12;i++)
  325.         {
  326.             PhoneNum[i] = 0;
  327.         }
  328. /*    do
  329.         {
  330.             i++;
  331.                 j=i+1;
  332.         }
  333.         //while((Pdu[i] == 'G') && (Pdu[j] == 'H'));
  334.         
  335.         index = j+1;
  336.         i = index;
  337.         while(Pdu[i++] == '+')numlen++;
  338.         
  339.         j = 79; */
  340.         
  341.         index = 79;
  342.         for(i=0;i<11;i++)
  343.         {
  344.             PhoneNum[i] = Pdu[index++];
  345.                 PhoneNum_to_EEPROM();
  346.     }
  347.         
  348. }        
  349. unsigned char CheckPhoneNum(void)
  350. {
  351.     unsigned char i;
  352.         for(i=0;i<12;i++)
  353.         {
  354.             if( PhoneNum != 0) return (FALSE);
  355.         }
  356.         return (TRUE);
  357. }
  358. /*-----------------------------------------------------------------------*/
  359. //////////////////////////    接收處理短信息    ///////////////////////////
  360. /*-----------------------------------------------------------------------*/
  361. void RecSMS(void)
  362. {
  363.     unsigned char count,i=0,j=0,x,y;
  364.         
  365.     Put_AT_String("AT+CMGR=1",9);
  366.         
  367.     while(RxBuf[i] != 0x0D)
  368.         {
  369.             i++;
  370.         }
  371.         i = 76;
  372.         j = i;
  373.         if((RxBuf[i] == 'G') && (RxBuf[j+1] == 'H'))
  374.     {        
  375.         count = 0;
  376.             while(1)
  377.             {
  378.                 Pdu[count] = RxBuf[count];
  379.                         x = count;
  380.                         y = count;
  381.                     if((RxBuf[x-2] == 0x30) && (RxBuf[y-1] == 0x0D))
  382.                     {
  383.                     break;
  384.                 }
  385.                     count++;
  386.             }
  387.                 CheckSMS();
  388.                 Delete_SMS(1);
  389.                
  390.     }
  391.         else
  392.         {
  393.             Delete_SMS(1);
  394.         }
  395. }

  397. unsigned char DetQEITING(void)
  398. {
  399.     volatile unsigned char tmp;
  400.         
  401.     if(!(DetQT()))
  402.     {
  403.             release = 0;
  404.             DelayMs(10);
  405.                
  406.                 if(!(DetQT())) {DettqFlag = 1;}
  407.     }
  408.         else
  409.         {
  410.             release = 1;
  411.         }
  412.                         
  413.         if(release && DettqFlag)
  414.         {
  415.             DettqFlag = 0;
  416.                 CplLED();

  418.                 return (TRUE);
  419.                
  420.         }
  421.         return (FALSE);
  422. }

  424. void IGT(unsigned char n)
  425. {
  426.     if(n)
  427.         {
  428.             PORTD &= ~(1<<PD6);
  429.                 DDRD |= (1<<PD6);
  430.         }
  431.         else
  432.         {
  433.             DDRD &= ~(1<<PD6);
  434.         }
  435. }
  436.                         
  437. void work(void)
  438. {
  439.     while(1)
  440.         {
  441.             if(CheckSMS_in())
  442.                 {
  443.                     RecSMS();
  444.             }
  445.                 if(CallInFlag)
  446.                 {
  447.                     Put_AT_command(Ata,AtaLen);
  448.                     CallInFlag = 0;
  449.                 }
  450.                 if((BusyFlag) || (NoCarrierFlag))  
  451.                 {
  452.                     Put_AT_command(Ath,AthLen);
  453.                         CallOut = 0;
  454.                         BusyFlag = 0;
  455.                         NoCarrierFlag = 0;
  456.                 }
  457.                 if(DetQEITING() && (!CallOut))
  458.                 {
  459.                     CallOut = 1;
  460.                     DialNum();
  461.                 }
  462.         }
  463. }
  464. /*-----------------------------------------------------------------------*/
  465. /////////////////////////////  初始化MC55    //////////////////////////////
  466. /*-----------------------------------------------------------------------*/
  467. void InitMC55(void)
  468. {
  469.          unsigned char tmp;
  470.     IGT(OFF);                                   
  471.     DelayMs(500);                                                                  // 置低MC55 IGT口 200mS ，啟動MC55模塊
  472.         IGT(ON);
  473.     DelayMs(500);
  474.     IGT(OFF);                                   


  477. //        DelayMs(1000);                             // 等待模塊啟動
  478.         

  480.         ClrRTS();
  481.     DelayMs(50);                              // 激活MC55串口
  482.         SetRTS();
  483.         DelayMs(50);
  484.         ClrRTS();
  485.     DelayMs(50);                              // 激活MC55串口
  486.         SetRTS();

  488. //        DelayMs(1000);                              // 激活MC55串口
  489.                
  490.     TxIndex = 0;
  491.     RxIndex = 0;
  492.         
  493.         while(!DetQEITING());
  494.         
  495.         PutString("AT",2,0);

  497.         DelayMs(500);      
  498.   
  499.         PutString("AT",2,1);
  500.         
  501.         PutString("ATV0",4,1);

  503.         PutString("ATE0",4,1);

  505.         PutString("AT+CNMI=2,1",11,1);

  507.         PutString("AT+CMGF=1",9,1);

  509.         Delete_SMS(ALL);
  510.         
  511.         PhoneNum_to_EEPROM();
  512.         
  513.         EEPROM_to_PhoneNum();

  515. }

  517. /////////////////////////////////////////////////////////////////////////////////
  518. /////////////////////////////////////////////////////////////////////////////////
  519. /////////////////////////////////////////////////////////////////////////////////
  520. /////////////////////////////////////////////////////////////////////////////////

  522. /*
  523. #pragma interrupt_handler int0_isr:2
  524. void int0_isr(void)
  525. {
  526. //external interupt on INT0
  527. DialNum();

  529. }

  531. #pragma interrupt_handler int1_isr:3
  532. void int1_isr(void)
  533. {
  534. //external interupt on INT1
  535. }
  536. */
  537. ////////////////////////////////////////////////////////////////////////////////

  539. void port_init(void)
  540. {
  541. PORTB = 0x01;
  542. DDRB  = 0x01;
  543. PORTC = 0x00; //m103 output only
  544. DDRC  = 0x02;
  545. PORTD = 0x0C;
  546. DDRD  = 0x50;
  547. }

  549. //UART0 initialize
  550. // desired baud rate: 19200
  551. // actual: baud rate:19200 (0.0%)
  552. // char size: 8 bit
  553. // parity: Disabled
  554. //#ifdef XTAL == 3.6864

  556. void uart0_init(void)
  557. {
  558. UCSRB = 0x00; //disable while setting baud rate
  559. UCSRA = 0x00;
  560. UCSRC = BIT(URSEL) | 0x06;
  561. UBRRL = 0x0B; //set baud rate lo
  562. UBRRH = 0x00; //set baud rate hi
  563. UCSRB = 0xD8;
  564. }
  565. //#endif

  567. //#ifdef XTAL == 7.3728
  568. /*void uart0_init(void)
  569. {
  570. UCSRB = 0x00; //disable while setting baud rate
  571. UCSRA = 0x00;
  572. UCSRC = BIT(URSEL) | 0x06;
  573. UBRRL = 0x17; //set baud rate lo
  574. UBRRH = 0x00; //set baud rate hi
  575. UCSRB = 0xD8;
  576. }*/
  577. //#endif

  579. //call this routine to initialize all peripherals
  580. void init_devices(void)
  581. {
  582. //stop errant interrupts until set up
  583. CLI(); //disable all interrupts
  584. port_init();
  585. uart0_init();

  587. MCUCR = 0x00;
  588. GICR  = 0x00; //0xC0;
  589. TIMSK = 0x00; //timer interrupt sources
  590. SEI(); //re-enable interrupts

  592. InitMC55();
  593. }



  597. //
  598. void main(void)
  599. {
  600. DelayMs(1000);
  601. init_devices();
  602. work();
  603. /*
  604. while(1)
  605. {
  606.     DetQEITING();
  607. }*/

  609. }

復制代碼
  1. ////////////////////////////////////////////////////////////////////////////////
  2. // ICC-AVR application builder : 2006-6-25 下午 06:02:39
  3. // Target : M8
  4. // Crystal: 3.6864Mhz
  5. // Author:  Anwarye
  6. // Title:   Detcetaphone
  7. ////////////////////////////////////////////////////////////////////////////////

  9. #include <iom8v.h>
  10. #include <macros.h>

  12. #define SetIGT()         (PORTD |= (1<<PD7))          // MC55模塊點火控制腳，高有效
  13. #define ClrIGT()     (PORTD &= ~(1<<PD7))

  15. #define SetLED()     (PORTB |= (1<<PB0))     // LED
  16. #define ClrLED()     (PORTB &= ~(1<<PB0))

  18. #define SetRTS()     (PORTD |= (1<<PD6))     // LED
  19. #define ClrRTS()     (PORTD &= ~(1<<PD6))

  21. #define DetRING0()   (PORTD & (1<<PD2))

  23. #define FALSE      0
  24. #define TRUE       1

  26. #define DONE       1
  27. #define UNDONE     0

  29. #define OK         1
  30. #define ERROR      0

  32. #define ALL        0xFF

  34. #define RX_BUF_SIZE  256
  35. #define TX_BUF_SIZE  32

  37. volatile unsigned char          TmpBuf[16];                // 臨時緩沖
  38. volatile unsigned char          Pdu[256];
  39. unsigned char                   RetCMGR[14];
  40. volatile unsigned char          PhoneNum[12];

  42. volatile unsigned char          RxBuf[RX_BUF_SIZE];                   // 串口接收緩沖
  43. volatile unsigned char   RxIndex = 0;                   // 串口接收緩沖指針
  44. volatile unsigned char   RxIndexTail = 0;               // 串口接收緩沖尾


  47. volatile unsigned char          TxBuf[TX_BUF_SIZE];                   // 發(fā)送緩沖
  48. volatile unsigned char   TxIndex = 0;                   // 發(fā)送緩沖指針


  51. volatile unsigned char RxStatus = 0;
  52. volatile unsigned char TxStatus = 1;

  54. volatile unsigned char OkFlag = 0;
  55. volatile unsigned char CallInFlag = 0;
  56. volatile unsigned char NoCarrierFlag = 0;
  57. volatile unsigned char BusyFlag = 0;

  59. /*-----------------------------------------------------------------------*/
  60. ///////////////////////////  串口發(fā)送使能  ////////////////////////////////
  61. /*-----------------------------------------------------------------------*/
  62. void TxEnable(void)
  63. {
  64.    
  65.     UDR = TxBuf[0];                            // 發(fā)送緩沖頭送入串口發(fā)送寄存器，激活開始發(fā)送
  66.         UCSRB |= ((1<<TXCIE));//|(1<<TXEN));
  67. }

  69. /*-----------------------------------------------------------------------*/
  70. /////////////////////////////  發(fā)送AT命令 /////////////////////////////////
  71. /*-----------------------------------------------------------------------*/
  72. void Put_AT_command(const unsigned char *atc, unsigned char atlen)
  73. {
  74.     unsigned char count;
  75.         
  76.         
  77.         
  78.         for(count = 0;count < atlen;count++)      // AT命令竄移入發(fā)送緩沖
  79.         {
  80.             TxBuf[count] = *atc+count;
  81.         }
  82.         
  83.         TxBuf[atlen] = 0x0D;                      // 發(fā)送緩沖竄結(jié)尾加“回車”
  84.         TxBuf[atlen + 1] = 0x00;                  // 發(fā)送緩沖竄結(jié)束符號

  86.         OkFlag = 0;
  87.     TxStatus = 0;
  88.         TxIndex = 1;                              // 發(fā)送指針偏移1
  89.         TxEnable();                               // 激活發(fā)送
  90.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  91.         while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束
  92.         
  93. }

  95. /*-----------------------------------------------------------------------*/
  96. /////////////////////////  從內(nèi)存發(fā)送AT命令串  ////////////////////////////
  97. /*-----------------------------------------------------------------------*/
  98. void Put_AT_String(unsigned char *atc, unsigned char atlen)
  99. {
  100.     unsigned char count;
  101.         for(count = 0;count < atlen;count++)
  102. //        while(*atc)     // AT命令竄移入發(fā)送緩沖
  103.         {
  104.             TxBuf[count] = *(atc+count);
  105.         }
  106.         
  107.         TxBuf[atlen] = 0x0D;                      // 發(fā)送緩沖竄結(jié)尾加“回車”
  108.         TxBuf[atlen + 1] = 0x00;                  // 發(fā)送緩沖竄結(jié)束符號

  110.     OkFlag = 0;
  111.     TxStatus = 0;
  112.         TxIndex = 1;                              // 發(fā)送指針偏移1
  113.         TxEnable();                               // 激活發(fā)送
  114.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  115.         while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束
  116. }
  117. /*-----------------------------------------------------------------------*/
  118. /////////////////////////  向串口發(fā)送一串數(shù)據(jù)  ////////////////////////////
  119. /*-----------------------------------------------------------------------*/
  120. void PutString(unsigned char *str, unsigned char length,unsigned char retflag)
  121. {
  122.     unsigned char count;
  123.         for(count = 0;count < length;count++)
  124.         {
  125.             TxBuf[count] = *(str+count);
  126.         }
  127.         
  128.         TxBuf[length] = 0x0D;                      // 發(fā)送緩沖竄結(jié)尾加“回車”
  129.         TxBuf[length+ 1] = 0x00;                  // 發(fā)送緩沖竄結(jié)束符號
  130.         
  131.     TxStatus = 0;
  132.         TxIndex = 1;                              // 發(fā)送指針偏移1
  133.         OkFlag = 0;
  134.         TxEnable();
  135.                                        // 激活發(fā)送
  136.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  137.     if(retflag)
  138.     {        
  139.         while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束
  140.         }
  141. }
  142. /*-----------------------------------------------------------------------*/
  143. /////////////////////////////  比較兩個串 /////////////////////////////////
  144. /*-----------------------------------------------------------------------*/
  145. unsigned char StringCompare(volatile unsigned char *str1,const unsigned char *str2,unsigned char strlen)
  146. {
  147.     while(strlen--)
  148.         {
  149.             if(*str1++ != *str2++) return(FALSE);    // 兩個串不相等返回假
  150.         }
  151.         return(TRUE);
  152. }

  154. /*-----------------------------------------------------------------------*/
  155. /////////////////////////////    刪除短信    //////////////////////////////
  156. /*-----------------------------------------------------------------------*/
  157. void Delete_SMS(unsigned char num)     // 刪除SMS，=0刪除所有SMS
  158. {
  159.     unsigned char count;

  161.         for(count = 0;count < AtcmgdLen;count++)      // AT命令竄移入發(fā)送緩沖
  162.         {
  163.             TmpBuf[count] = Atcmgd[count];
  164.         }
  165.                
  166.         if(num == ALL)
  167.         {
  168.            for(count = 1; count < 10; count++)
  169.            {
  170.                TmpBuf[AtcmgdLen] = count + 0x30;
  171.                Put_AT_String((unsigned char*)TmpBuf,(AtcmgdLen+1));

  173.                 }
  174.            TmpBuf[AtcmgdLen] = 0x31;
  175.        for(count = 0; count < 10; count++)
  176.            {
  177.                TmpBuf[AtcmgdLen+1] = count + 0x30;
  178.                Put_AT_String((unsigned char*)TmpBuf,(AtcmgdLen+2));

  180.             }

  182.         }
  183.         else
  184.         {
  185.             TmpBuf[AtcmgdLen] = num + 0x30;
  186.             Put_AT_String((unsigned char*)TmpBuf,(AtcmgdLen+1));

  188.         }
  189. }

  191. /*-----------------------------------------------------------------------*/
  192. //////////////////////////    接收處理短信息    ///////////////////////////
  193. /*-----------------------------------------------------------------------*/
  194. void RecSMS(void)
  195. {
  196.     unsigned char ch,count;
  197.         
  198.     Put_AT_String("AT+CMGR=1",9);
  199.         
  200.     count = 0;
  201.         while(1)
  202.         {
  203.             Pdu[count] = RxBuf[count];
  204.                 if((RxBuf[count-2] == 0x30) && (RxBuf[count-1] == 0x0D))
  205.                 {
  206.                     break;
  207.             }
  208.                 count++;
  209.         }
  210. }

  212. /*-----------------------------------------------------------------------*/
  213. ///////////////    檢查SMS是否有用并將設(shè)置號碼存入內(nèi)存    /////////////////
  214. /*-----------------------------------------------------------------------*/
  215. void CheckSMS(void)
  216. {
  217.     unsigned char i;
  218.         i = 1;
  219. }        

  221. ////////////////////////////////////////////////////////////////////////////////

  223. /*-----------------------------------------------------------------------*/
  224. //////////////////////////         撥號         ///////////////////////////
  225. /*-----------------------------------------------------------------------*/
  226. void DialNum(void)
  227. {
  228.     unsigned char count=0,length=0;
  229.         while (PhoneNum[count++])                  // 計算電話號碼長度
  230.         {
  231.             length++;
  232.         }
  233.         
  234.         TxBuf[0] = 'A';
  235.         TxBuf[1] = 'T';
  236.         TxBuf[2] = 'D';
  237.         
  238.     for(count=0;count<length;count++)
  239.         {
  240.             TxBuf[count+3] = PhoneNum[count];
  241.         }
  242.    
  243.         TxBuf[length] = ';';
  244.         TxBuf[length++] = 0x0D;
  245.         
  246.     OkFlag = 0;
  247.     TxStatus = 0;
  248.         TxIndex = 1;                              // 發(fā)送指針偏移1
  249.         TxEnable();                               // 激活發(fā)送
  250.     while(!TxStatus);                         // 等代發(fā)送結(jié)束,發(fā)送緩沖指針為零則可以發(fā)送
  251.         while(!OkFlag);                           // 收到模塊返回OK,命令結(jié)束        
  252. }


  255. /*-----------------------------------------------------------------------*/
  256. /////////////////////////////  初始化MC55    //////////////////////////////
  257. /*-----------------------------------------------------------------------*/
  258. void InitMC55(void)
  259. {
  260.          unsigned char tmp;
  261.     SetIGT();                                   
  262.     DelayMs(200);                                                                  // 置低MC55 IGT口 200mS ，啟動MC55模塊
  263.         ClrIGT();

  265.         DelayMs(50);                             // 等待模塊啟動

  267.         ClrRTS();
  268.     DelayMs(50);                              // 激活MC55串口
  269.         SetRTS();
  270.         DelayMs(50);
  271.         ClrRTS();
  272.     DelayMs(50);                              // 激活MC55串口
  273.         SetRTS();

  275.         DelayMs(500);                              // 激活MC55串口
  276.         
  277.         
  278.     TxIndex = 0;
  279.     RxIndex = 0;
  280.         
  281.     Put_AT_command(At,AtLen);                 // 發(fā)送AT命令校準串口，如果失敗嘗試10次后結(jié)束

  283.         
  284.     Put_AT_command(Atf,AtfLen);               // 發(fā)送AT&F命令恢復MC55模塊出廠設(shè)置
  285.         
  286.         
  287.         Put_AT_command(Atv1,Atv1Len);            // 設(shè)置模塊返回碼格式 V0 = 簡單返回數(shù)字 V1=復雜返回文本

  289.         
  290.         Put_AT_command(Ate0,Ate0Len);            // 關(guān)閉MC55串口回顯

  292.         
  293.         Delete_SMS(1);

  295. }        
復制代碼
作者: 大漠落日    時間: 2024-3-1 22:06
吹牛吧，看看代碼是讀取短信的程序
作者: herohuang    時間: 2024-4-2 17:05
這個AT指令不太靠譜



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1