设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › AVR单片机 › M8单片机串口通讯监听(使用PROTEUS串口仿真GSM模块AT指 ...
返回列表 发新帖
查看: 5453|回复: 2
打印 上一主题 下一主题
收起左侧

M8单片机串口通讯监听(使用PROTEUS串口仿真GSM模块AT指令通讯)源码

[复制链接]
跳转到指定楼层
楼主
ID:293738 发表于 2018-3-19 16:35 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
实现监听(使用PROTEUS串口例子)V1.0
M8单片机仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）：


全部资料51hei下载地址：
窃听器(使用PROTEUS串口例子)V1.0.zip (123.24 KB, 下载次数: 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;                 // 继续接收数据放入接收缓冲
  72.         RxStatus = 0;                         // 串口接收中
  73. //        return;                                                                     // 结束接收，直接跳出
  74.         }
  75. }

  77. ////////////////////////////////////////////////////////////////////////////////
  78. #pragma interrupt_handler uart0_tx_isr:14
  79. void uart0_tx_isr(void)
  80. {
  81.    
  82.     if(!TxStatus)                                   // 本帧数据未发完，则继续发送  
  83.         {
  84.             //while ( !(UCSRA & (1<<UDRE)) );             // 等待UDR空
  85.             UDR = TxBuf[TxIndex];               
  86.         }
  87.         if((TxBuf[TxIndex] == 0x0D) || (TxBuf[TxIndex] == 0x1A))  // 本帧数据发送结束
  88.         {
  89.                 TxStatus = 1;                          // 发送完成状态标志置位
  90.                 TxIndex = 0;                           // 发送缓冲区指针归零
  91.                 UCSRB &= ~((1<<TXCIE));//|(1<<TXEN));  // 关发送中断
  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. ///////////////////////////  串口发送使能  ////////////////////////////////
  124. /*-----------------------------------------------------------------------*/
  125. void TxEnable(void)
  126. {
  127.     //RxIndex = 0;
  128.     UDR = TxBuf[0];                            // 发送缓冲头送入串口发送寄存器，激活开始发送
  129.         UCSRB |= ((1<<TXCIE));//|(1<<TXEN));
  130. }
  131. /*-----------------------------------------------------------------------*/
  132. /////////////////////////////  发送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命令窜移入发送缓冲
  139.         {
  140.             TxBuf[count] = atc[count];
  141.         }
  142.         
  143.         TxBuf[atlen] = 0x0D;                      // 发送缓冲窜结尾加“回车”
  144.         TxBuf[atlen + 1] = 0x00;                  // 发送缓冲窜结束符号

  146.         OkFlag = 0;
  147.     TxStatus = 0;
  148.         TxIndex = 1;                              // 发送指针偏移1
  149.         TxEnable();                               // 激活发送
  150.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  151.         DelayMs(20);
  152.         while(!OkFlag);                           // 收到模块返回OK,命令结束
  153.         OkFlag = 0;

  155. }

  157. /*-----------------------------------------------------------------------*/
  158. /////////////////////////  从内存发送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;                      // 发送缓冲窜结尾加“回车”
  170.         TxBuf[atlen + 1] = 0x00;                  // 发送缓冲窜结束符号

  172.     OkFlag = 0;
  173.     TxStatus = 0;
  174.         TxIndex = 1;                              // 发送指针偏移1
  175.         TxEnable();                               // 激活发送
  176.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  177.         DelayMs(20);
  178.         while(!OkFlag);                           // 收到模块返回OK,命令结束
  179.         OkFlag = 0;
  180. }
  181. /*-----------------------------------------------------------------------*/
  182. /////////////////////////  向串口发送一串数据  ////////////////////////////
  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;                     // 发送缓冲窜结尾加“回车”
  194.         TxBuf[length+ 1] = 0x00;                  // 发送缓冲窜结束符号
  195.         
  196.     TxStatus = 0;
  197.         TxIndex = 1;                              // 发送指针偏移1
  198.         OkFlag = 0;
  199.         TxEnable();
  200.                                                   // 激活发送
  201.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  202.         DelayMs(20);
  203.     if(retflag)
  204.     {        
  205.         while(!OkFlag);                       // 收到模块返回OK,命令结束
  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;                              // 发送指针偏移1
  244.         TxEnable();                               // 激活发送
  245.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  246.         DelayMs(20);
  247.         //while(!OkFlag);                           // 收到模块返回OK,命令结束        
  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命令窜移入发送缓冲
  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. ///////////////              将设置号码存入内存           /////////////////
  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];                   // 发送缓冲
  48. volatile unsigned char   TxIndex = 0;                   // 发送缓冲指针


  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. ///////////////////////////  串口发送使能  ////////////////////////////////
  61. /*-----------------------------------------------------------------------*/
  62. void TxEnable(void)
  63. {
  64.    
  65.     UDR = TxBuf[0];                            // 发送缓冲头送入串口发送寄存器，激活开始发送
  66.         UCSRB |= ((1<<TXCIE));//|(1<<TXEN));
  67. }

  69. /*-----------------------------------------------------------------------*/
  70. /////////////////////////////  发送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命令窜移入发送缓冲
  79.         {
  80.             TxBuf[count] = *atc+count;
  81.         }
  82.         
  83.         TxBuf[atlen] = 0x0D;                      // 发送缓冲窜结尾加“回车”
  84.         TxBuf[atlen + 1] = 0x00;                  // 发送缓冲窜结束符号

  86.         OkFlag = 0;
  87.     TxStatus = 0;
  88.         TxIndex = 1;                              // 发送指针偏移1
  89.         TxEnable();                               // 激活发送
  90.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  91.         while(!OkFlag);                           // 收到模块返回OK,命令结束
  92.         
  93. }

  95. /*-----------------------------------------------------------------------*/
  96. /////////////////////////  从内存发送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命令窜移入发送缓冲
  103.         {
  104.             TxBuf[count] = *(atc+count);
  105.         }
  106.         
  107.         TxBuf[atlen] = 0x0D;                      // 发送缓冲窜结尾加“回车”
  108.         TxBuf[atlen + 1] = 0x00;                  // 发送缓冲窜结束符号

  110.     OkFlag = 0;
  111.     TxStatus = 0;
  112.         TxIndex = 1;                              // 发送指针偏移1
  113.         TxEnable();                               // 激活发送
  114.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  115.         while(!OkFlag);                           // 收到模块返回OK,命令结束
  116. }
  117. /*-----------------------------------------------------------------------*/
  118. /////////////////////////  向串口发送一串数据  ////////////////////////////
  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;                      // 发送缓冲窜结尾加“回车”
  129.         TxBuf[length+ 1] = 0x00;                  // 发送缓冲窜结束符号
  130.         
  131.     TxStatus = 0;
  132.         TxIndex = 1;                              // 发送指针偏移1
  133.         OkFlag = 0;
  134.         TxEnable();
  135.                                        // 激活发送
  136.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  137.     if(retflag)
  138.     {        
  139.         while(!OkFlag);                           // 收到模块返回OK,命令结束
  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命令窜移入发送缓冲
  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是否有用并将设置号码存入内存    /////////////////
  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;                              // 发送指针偏移1
  249.         TxEnable();                               // 激活发送
  250.     while(!TxStatus);                         // 等代发送结束,发送缓冲指针为零则可以发送
  251.         while(!OkFlag);                           // 收到模块返回OK,命令结束        
  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);                 // 发送AT命令校准串口，如果失败尝试10次后结束

  283.         
  284.     Put_AT_command(Atf,AtfLen);               // 发送AT&F命令恢复MC55模块出厂设置
  285.         
  286.         
  287.         Put_AT_command(Atv1,Atv1Len);            // 设置模块返回码格式 V0 = 简单返回数字 V1=复杂返回文本

  289.         
  290.         Put_AT_command(Ate0,Ate0Len);            // 关闭MC55串口回显

  292.         
  293.         Delete_SMS(1);

  295. }        
复制代码

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:195496 发表于 2024-3-1 22:06 | 只看该作者
吹牛吧，看看代码是读取短信的程序
回复

使用道具 举报

板凳
ID:101305 发表于 2024-4-2 17:05 | 只看该作者
这个AT指令不太靠谱
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表