单片机教程网

电脑版
提示:原网页已由神马搜索转码, 内容由www.51hei.com提供.
查看:5650|回复: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. }      
复制代码

评分

黑币 +50
收起理由
+ 50
共享资料的黑币奖励！

查看全部评分

沙发
ID:195496发表于 2024-3-1 22:06|只看该作者
吹牛吧，看看代码是读取短信的程序
板凳
ID:101305发表于 2024-4-2 17:05|只看该作者
这个AT指令不太靠谱

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

Powered by 单片机教程网