单片机串口调用at指令_51单片机单串口同时实现at指令和调试信息输出时怎么输入指令 - CSDN
  • 很多外部模块是使用串口的方式与单片机通信的,但有的...我们可以保留单片机串口与PC的连接,串口同时与模块连接,这样单片机的发送信息同时被模块和PC收到了。 模块只对AT指令有反应,对其他格式不正确的指令无反应,

    很多外部模块是使用串口的方式与单片机通信的,但有的单片机只有一个串口,且不能硬件仿真,比如我使用的STC90C516,如果将唯一的串口给了外部模块,就不能打印调试信息了。

    不过如果是使用AT指令只这样的模块,比如蓝牙SPP,WiFi模块,是使用AT指令的方式通信的

    我们可以保留单片机串口与PC的连接,串口同时与模块连接,这样单片机的发送信息同时被模块和PC收到了。

    模块只对AT指令有反应,对其他格式不正确的指令无反应,

    如:

    printf("AT+RST\r\n");//模块对该指令有反应
    printf("DEBUG+RST Test\r\n");//模块对该指令无反应</span>

    这样串口就可以接收发送的数据和调试信息了,注意指令后面要加换行符。

    展开全文
  • Q 用串口连接GSM手机发送和接收短消息,在应用程序中如何编程实现? Q 我们打算开发一个基于GSM短消息方式的GPS系统,如何利用SMS进行数据通信? A 首先,我们要对由ESTI制订的SMS规范有所了解。与我们讨论的短...

    Q 用串口连接GSM手机发送和接收短消息,在应用程序中如何编程实现?

    Q 我们打算开发一个基于GSM短消息方式的GPS系统,如何利用SMS进行数据通信?

    A 首先,我们要对由ESTI制订的SMS规范有所了解。与我们讨论的短消息收发有关的规范主要包括GSM 03.38、GSM 03.40和GSM 07.05。前二者着重描述SMS的技术实现(含编码方式),后者则规定了SMS的DTE-DCE接口标准(AT命令集)。

    一共有三种方式来发送和接收SMS信息:Block Mode, Text Mode和PDU Mode。Block Mode已是昔日黄花,目前很少用了。Text Mode是纯文本方式,可使用不同的字符集,主要用于欧美地区。从技术上说也可用于发送中文短消息,但国内手机基本上不支持。PDU Mode被所有手机支持,可以使用任何字符集,这也是手机默认的编码方式。Text Mode比较简单,而且不适合做自定义数据传输,我们就不讨论了。下面介绍的内容,是在PDU Mode下发送和接收短消息的实现方法。

    PDU串表面上是一串ASCII码,由‘0''-‘9''、 ‘A''-‘F''这些数字和字母组成。它们是8位字节的十六进制数,或者BCD码十进制数。PDU串不仅包含可显示的消息本身,还包含很多其它信息,如SMS服务中心号码、目标号码、回复号码、编码方式和服务时间等。发送和接收的PDU串,结构是不完全相同的。我们先用两个实际的例子说明PDU串的结构和编排方式。

    例1 发送:SMSC号码是+8613800250500,对方号码是13851872468,消息内容是“Hello!”。从手机发出的PDU串可以是

    08 91 68 31 08 20 05 05 F0 11 00 0D 91 68 31 58 81 27 64 F8 00 00 00 06 C8 32 9B FD 0E 01

    对照规范,具体分析:

    分段 含义 说明
    08 SMSC地址信息的长度 共8个八位字节(包括91)
    91 SMSC地址格式(TON/NPI) 用国际格式号码(在前面加‘+’)
    68 31 08 20 05 05 F0 SMSC地址 8613800250500,补‘F’凑成偶数个
    11 基本参数(TP-MTI/VFP) 发送,TP-VP用相对格式
    00 消息基准值(TP-MR) 0
    0D 目标地址数字个数 共13个十进制数(不包括91和‘F’)
    91 目标地址格式(TON/NPI) 用国际格式号码(在前面加‘+’)
    68 31 58 81 27 64 F8 目标地址(TP-DA) 8613851872468,补‘F’凑成偶数个
    00 协议标识(TP-PID) 是普通GSM类型,点到点方式
    00 用户信息编码方式(TP-DCS) 7-bit编码
    00 有效期(TP-VP) 5分钟
    06 用户信息长度(TP-UDL) 实际长度6个字节
    C8 32 9B FD 0E 01 用户信息(TP-UD) “Hello!”

    例2 接收:SMSC号码是+8613800250500,对方号码是13851872468,消息内容是“你好!”。手机接收到的PDU串可以是

    08 91 68 31 08 20 05 05 F0 84 0D 91 68 31 58 81 27 64 F8 00 08 30 30 21 80 63 54 80 06 4F 60 59 7D 00 21

    对照规范,具体分析:

    分段 含义 说明
    08 地址信息的长度 个八位字节(包括91)
    91 SMSC地址格式(TON/NPI) 用国际格式号码(在前面加‘+’)
    68 31 08 20 05 05 F0 SMSC地址 8613800250500,补‘F’凑成偶数个
    84 基本参数(TP-MTI/MMS/RP) 接收,无更多消息,有回复地址
    0D 源地址数字个数 共13个十进制数(不包括91和‘F’)
    91 源地址格式(TON/NPI) 用国际格式号码(在前面加‘+’)
    68 31 58 81 27 64 F8 源地址(TP-OA) 8613851872468,补‘F’凑成偶数个
    00 协议标识(TP-PID) 是普通GSM类型,点到点方式
    08 用户信息编码方式(TP-DCS) UCS2编码
    30 30 21 80 63 54 80 时间戳(TP-SCTS) 2003-3-12 08:36:45  +8时区
    06 用户信息长度(TP-UDL) 实际长度6个字节
    4F 60 59 7D 00 21 用户信息(TP-UD) “你好!”

    注意号码和时间的表示方法,不是按正常顺序来的,而且要以‘F''将奇数补成偶数。

    Q 上面两例中已经出现了7-bit和UCS2编码,请详细介绍一下这些编码方式?

    A 在PDU Mode中,可以采用三种编码方式来对发送的内容进行编码,它们是7-bit、8-bit和UCS2编码。7-bit编码用于发送普通的ASCII字符,它将一串7-bit的字符(最高位为0)编码成8-bit的数据,每8个字符可“压缩”成7个;8-bit编码通常用于发送数据消息,比如图片和铃声等;而UCS2编码用于发送Unicode字符。在这三种编码方式下,PDU串的用户信息(TP-UD)段最大容量(可以发送的短消息的最大字符数)分别是160、140和70。这里,将一个英文字母、一个汉字和一个数据字节都视为一个字符。

    需要注意的是,PDU串的用户信息长度(TP-UDL),在各种编码方式下意义有所不同。7-bit编码时,指原始短消息的字符个数,而不是编码后的字节数。8-bit编码时,就是字节数。UCS2编码时,也是字节数,等于原始短消息的字符数的两倍。如果用户信息(TP-UD)中存在一个头(基本参数的TP-UDHI为1),在所有编码方式下,用户信息长度(TP-UDL)都等于头长度与编码后字节数之和。如果采用GSM 03.42所建议的压缩算法(TP-DCS的高3位为001),则该长度也是压缩编码后字节数或头长度与压缩编码后字节数之和。

    下面以一个具体的例子说明7-bit编码的过程。我们对英文短信“Hello!”进行编码:

    将源串每8个字符分为一组(这个例子中不满8个)进行编码,在组内字符间压缩,但每组之间是没有什么联系的。

    用C实现7-bit编码和解码的算法如下:

    // 7-bit编码
    // pSrc: 源字符串指针
    // pDst: 目标编码串指针
    // nSrcLength: 源字符串长度
    // 返回: 目标编码串长度
    int gsmEncode7bit(const char* pSrc, unsigned char* pDst, int nSrcLength)
    {
        int nSrc;        // 源字符串的计数值
        int nDst;        // 目标编码串的计数值
        int nChar;       // 当前正在处理的组内字符字节的序号,范围是0-7
        unsigned char nLeft;    // 上一字节残余的数据
      
        // 计数值初始化
        nSrc = 0;
        nDst = 0;
      
        // 将源串每8个字节分为一组,压缩成7个字节
        // 循环该处理过程,直至源串被处理完
        // 如果分组不到8字节,也能正确处理
        while (nSrc < nSrcLength)
        {
            // 取源字符串的计数值的最低3位
            nChar = nSrc & 7;
      
            // 处理源串的每个字节
            if (nChar == 0)
            {
                // 组内第一个字节,只是保存起来,待处理下一个字节时使用
                nLeft = *pSrc;
            }
            else
            {
                // 组内其它字节,将其右边部分与残余数据相加,得到一个目标编码字节
                *pDst = (*pSrc << (8 - nChar)) | nLeft;
      
                // 将该字节剩下的左边部分,作为残余数据保存起来
                nLeft = *pSrc >> nChar;
    
                // 修改目标串的指针和计数值
                pDst++;
                nDst++;
            }
      
            // 修改源串的指针和计数值
            pSrc++;
            nSrc++;
        }
      
        // 返回目标串长度
        return nDst;
    }
      
    // 7-bit解码
    // pSrc: 源编码串指针
    // pDst: 目标字符串指针
    // nSrcLength: 源编码串长度
    // 返回: 目标字符串长度
    int gsmDecode7bit(const unsigned char* pSrc, char* pDst, int nSrcLength)
    {
        int nSrc;        // 源字符串的计数值
        int nDst;        // 目标解码串的计数值
        int nByte;       // 当前正在处理的组内字节的序号,范围是0-6
        unsigned char nLeft;    // 上一字节残余的数据
      
        // 计数值初始化
        nSrc = 0;
        nDst = 0;
      
        // 组内字节序号和残余数据初始化
        nByte = 0;
        nLeft = 0;
      
        // 将源数据每7个字节分为一组,解压缩成8个字节
        // 循环该处理过程,直至源数据被处理完
        // 如果分组不到7字节,也能正确处理
        while (nSrc < nSrcLength)
        {
            // 将源字节右边部分与残余数据相加,去掉最高位,得到一个目标解码字节
            *pDst = ((*pSrc << nByte) | nLeft) & 0x7f;
    
            // 将该字节剩下的左边部分,作为残余数据保存起来
            nLeft = *pSrc >> (7 - nByte);
      
            // 修改目标串的指针和计数值
            pDst++;
            nDst++;
      
            // 修改字节计数值
            nByte++;
      
            // 到了一组的最后一个字节
            if (nByte == 7)
            {
                // 额外得到一个目标解码字节
                *pDst = nLeft;
      
                // 修改目标串的指针和计数值
                pDst++;
                nDst++;
      
                // 组内字节序号和残余数据初始化
                nByte = 0;
                nLeft = 0;
            }
      
            // 修改源串的指针和计数值
            pSrc++;
            nSrc++;
        }
      
        *pDst = 0;
      
        // 返回目标串长度
        return nDst;
    }
    
    

    需要指出的是,7-bit的字符集与ANSI标准字符集不完全一致,在0x20以下也排布了一些可打印字符,但英文字母、阿拉伯数字和常用符号的位置两者是一样的。用上面介绍的算法收发纯英文短消息,一般情况应该是够用了。如果是法语、德语、西班牙语等,含有“å”、 “é”这一类字符,则要按上面编码的输出去查表,请参阅GSM 03.38的规定。

    8-bit编码其实没有规定什么具体的算法,不需要介绍。

    UCS2编码是将每个字符(1-2个字节)按照ISO/IEC10646的规定,转变为16位的Unicode宽字符。在Windows系统中,特别是在2000/XP中,可以简单地调用API 函数实现编码和解码。如果没有系统的支持,比如用单片机控制手机模块收发短消息,只好用查表法解决了。

    Windows环境下,用C实现UCS2编码和解码的算法如下:

    // UCS2编码
    // pSrc: 源字符串指针
    // pDst: 目标编码串指针
    // nSrcLength: 源字符串长度
    // 返回:目标编码串长度
    int gsmEncodeUcs2(const char* pSrc, unsigned char* pDst, int nSrcLength)
    {
        int        nDstLength; // UNICODE宽字符数目
        WCHAR      wchar[128]; // UNICODE串缓冲区
        
        //字符串-->UNICODE串
        nDstLength = MultiByteToWideChar(CP_ACP, 0, pSrc, nSrcLength, wchar, 128);
      
        // 高低字节对调,输出
        for (int i = 0; i < nDstLength; i++)
        {
            // 先输出高位字节
            *pDst++ = wchar[i] >> 8;
    
            // 后输出低位字节
            *pDst++ = wchar[i] & 0xff;
        }
      
        // 返回目标编码串长度
        return nDstLength * 2;
    }
      
    // UCS2解码
    // pSrc: 源编码串指针
    // pDst: 目标字符串指针
    // nSrcLength: 源编码串长度
    // 返回: 目标字符串长度
    int gsmDecodeUcs2(const unsigned char* pSrc, char* pDst, int nSrcLength)
    {
        int nDstLength;        // UNICODE宽字符数目
        WCHAR wchar[128];      // UNICODE串缓冲区
      
        // 高低字节对调,拼成UNICODE
        for (int i = 0; i < nSrcLength/2; i++)
        {
            // 先高位字节
            wchar[i] = *pSrc++ << 8;
      
            // 后低位字节
            wchar[i] |= *pSrc++;
      
        }
        
        //UNICODE串-->字符串
        nDstLength = WideCharToMultiByte(CP_ACP, 0, wchar, nSrcLength/2, pDst, 160, NULL, NULL);
      
        // 返回目标字符串长度
        return nDstLength;
    }
    
    

    用以上编码和解码模块,还不能将短消息字符串编码为PDU串需要的格式,也不能直接将PDU串中的用户信息解码为短消息字符串,因为还差一个在可打印字符串和字节数据之间相互转换的环节。可以循环调用sscanf和sprintf函数实现这种变换。下面提供不用这些函数的算法,它们也适用于单片机、DSP编程环境。

    // 可打印字符串转换为字节数据
    // 如:"C8329BFD0E01" --> {0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01}
    // pSrc: 源字符串指针
    // pDst: 目标数据指针
    // nSrcLength: 源字符串长度
    // 返回: 目标数据长度
    int gsmString2Bytes(const char* pSrc, unsigned char* pDst, int nSrcLength)
    {
        for (int i = 0; i < nSrcLength; i++)
        {
            // 输出高4位
            if (*pSrc > = ''0'' && *pSrc <= ''9'')
            {
                *pDst = (*pSrc - ''0'') << 4;
            }
            else
            {
                *pDst = (*pSrc - ''A'' + 10) << 4;
            }
      
            pSrc++;
      
            // 输出低4位
            if (*pSrc >= ''0'' && *pSrc <= ''9'')
            {
                *pDst |= *pSrc - ''0'';
            }
            else
            {
                *pDst |= *pSrc - ''A'' + 10;
            }
    
            pSrc++;
            pDst++;
        }
      
        // 返回目标数据长度
        return nSrcLength / 2;
    }
      
    // 字节数据转换为可打印字符串
    // 如:{0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01} --> "C8329BFD0E01"
    // pSrc: 源数据指针
    // pDst: 目标字符串指针
    // nSrcLength: 源数据长度
    // 返回: 目标字符串长度
    int gsmBytes2String(const unsigned char* pSrc, char* pDst, int nSrcLength)
    {
        const char tab[]="0123456789ABCDEF";    // 0x0-0xf的字符查找表
      
        for (int i = 0; i < nSrcLength; i++)
        {
            // 输出高4位
            *pDst++ = tab[*pSrc >> 4];
      
            // 输出低4位
            *pDst++ = tab[*pSrc & 0x0f];
      
            pSrc++;
        }
      
        // 输出字符串加个结束符
        *pDst = ''/0'';
      
        // 返回目标字符串长度
        return nSrcLength * 2;
    }
    
    

    关于GSM 03.42中的压缩算法,至今还没有发现哪里用过,这里我们就不讨论了。有兴趣的话,可深入研究一下。


    通过串口使用AT指令发送短消息(下)


    Q PDU的核心编码方式已经清楚了,如何实现用AT命令收发短消息呢?

    A 在上篇中,我们已经讨论了7bit, 8bit和UCS2这几种PDU用户信息的编码方式,并且给出了实现代码。现在,重点描述PDU全串的编码和解码过程,以及GSM 07.05的AT命令实现方法。这些是底层的核心代码,为了保证代码的可移植性,我们尽可能不用MFC的类,必要时用ANSI C标准库函数。

    首先,定义如下常量和结构:

    // 用户信息编码方式
    #define GSM_7BIT        0
    #define GSM_8BIT        4
    #define GSM_UCS2        8
      
    // 短消息参数结构,编码/解码共用
    // 其中,字符串以''/0''结尾
    typedef struct {
        char SCA[16];       // 短消息服务中心号码(SMSC地址)
        char TPA[16];       // 目标号码或回复号码(TP-DA或TP-RA)
        char TP_PID;        // 用户信息协议标识(TP-PID)
        char TP_DCS;        // 用户信息编码方式(TP-DCS)
        char TP_SCTS[16];   // 服务时间戳字符串(TP_SCTS), 接收时用到
        char TP_UD[161];    // 原始用户信息(编码前或解码后的TP-UD)
        char index;         // 短消息序号,在读取时用到
    } SM_PARAM;
    
    

    大家已经注意到PDU串中的号码和时间,都是两两颠倒的字符串。利用下面两个函数可进行正反变换:

    // 正常顺序的字符串转换为两两颠倒的字符串,若长度为奇数,补''F''凑成偶数
    // 如:"8613851872468" --> "683158812764F8"
    // pSrc: 源字符串指针
    // pDst: 目标字符串指针
    // nSrcLength: 源字符串长度
    // 返回: 目标字符串长度
    int gsmInvertNumbers(const char* pSrc, char* pDst, int nSrcLength)
    {
        int nDstLength;   // 目标字符串长度
        char ch;          // 用于保存一个字符
      
        // 复制串长度
        nDstLength = nSrcLength;
      
        // 两两颠倒
        for (int i = 0; i < nSrcLength; i += 2)
        {
            ch = *pSrc++;        // 保存先出现的字符
            *pDst++ = *pSrc++;   // 复制后出现的字符
            *pDst++ = ch;        // 复制先出现的字符
        }
      
        // 源串长度是奇数吗?
        if (nSrcLength & 1)
        {
            *(pDst-2) = ''F'';     // 补''F''
            nDstLength++;        // 目标串长度加1
        }
      
        // 输出字符串加个结束符
        *pDst = ''/0'';
      
        // 返回目标字符串长度
        return nDstLength;
    }
      
    // 两两颠倒的字符串转换为正常顺序的字符串
    // 如:"683158812764F8" --> "8613851872468"
    // pSrc: 源字符串指针
    // pDst: 目标字符串指针
    // nSrcLength: 源字符串长度
    // 返回: 目标字符串长度
    int gsmSerializeNumbers(const char* pSrc, char* pDst, int nSrcLength)
    {
        int nDstLength;   // 目标字符串长度
        char ch;          // 用于保存一个字符
      
        // 复制串长度
        nDstLength = nSrcLength;
      
        // 两两颠倒
        for (int i = 0; i < nSrcLength; i += 2)
        {
            ch = *pSrc++;        // 保存先出现的字符
            *pDst++ = *pSrc++;   // 复制后出现的字符
            *pDst++ = ch;        // 复制先出现的字符
        }
      
        // 最后的字符是''F''吗?
        if (*(pDst-1) == ''F'')
        {
            pDst--;
            nDstLength--;        // 目标字符串长度减1
        }
      
        // 输出字符串加个结束符
        *pDst = ''/0'';
      
        // 返回目标字符串长度
        return nDstLength;
    }
    

    以下是PDU全串的编解码模块。为简化编程,有些字段用了固定值。

    // PDU编码,用于编制、发送短消息
    // pSrc: 源PDU参数指针
    // pDst: 目标PDU串指针
    // 返回: 目标PDU串长度
    int gsmEncodePdu(const SM_PARAM* pSrc, char* pDst)
    {
        int nLength;             // 内部用的串长度
        int nDstLength;          // 目标PDU串长度
        unsigned char buf[256];  // 内部用的缓冲区
      
        // SMSC地址信息段
        nLength = strlen(pSrc->SCA);    // SMSC地址字符串的长度
        buf[0] = (char)((nLength & 1) == 0 ? nLength : nLength + 1) / 2 + 1;    // SMSC地址信息长度
        buf[1] = 0x91;        // 固定: 用国际格式号码
        nDstLength = gsmBytes2String(buf, pDst, 2);        // 转换2个字节到目标PDU串
        nDstLength += gsmInvertNumbers(pSrc->SCA, &pDst[nDstLength], nLength);    // 转换SMSC到目标PDU串
      
        // TPDU段基本参数、目标地址等
        nLength = strlen(pSrc->TPA);    // TP-DA地址字符串的长度
        buf[0] = 0x11;            // 是发送短信(TP-MTI=01),TP-VP用相对格式(TP-VPF=10)
        buf[1] = 0;               // TP-MR=0
        buf[2] = (char)nLength;   // 目标地址数字个数(TP-DA地址字符串真实长度)
        buf[3] = 0x91;            // 固定: 用国际格式号码
        nDstLength += gsmBytes2String(buf, &pDst[nDstLength], 4);  // 转换4个字节到目标PDU串
        nDstLength += gsmInvertNumbers(pSrc->TPA, &pDst[nDstLength], nLength); // 转换TP-DA到目标PDU串
      
        // TPDU段协议标识、编码方式、用户信息等
        nLength = strlen(pSrc->TP_UD);    // 用户信息字符串的长度
        buf[0] = pSrc->TP_PID;        // 协议标识(TP-PID)
        buf[1] = pSrc->TP_DCS;        // 用户信息编码方式(TP-DCS)
        buf[2] = 0;            // 有效期(TP-VP)为5分钟
        if (pSrc->TP_DCS == GSM_7BIT)
        {
            // 7-bit编码方式
            buf[3] = nLength;            // 编码前长度
            nLength = gsmEncode7bit(pSrc->TP_UD, &buf[4], nLength+1) + 4;    // 转换TP-DA到目标PDU串
        }
        else if (pSrc->TP_DCS == GSM_UCS2)
        {
            // UCS2编码方式
            buf[3] = gsmEncodeUcs2(pSrc->TP_UD, &buf[4], nLength);    // 转换TP-DA到目标PDU串
            nLength = buf[3] + 4;        // nLength等于该段数据长度
        }
        else
        {
            // 8-bit编码方式
            buf[3] = gsmEncode8bit(pSrc->TP_UD, &buf[4], nLength);    // 转换TP-DA到目标PDU串
            nLength = buf[3] + 4;        // nLength等于该段数据长度
        }
        nDstLength += gsmBytes2String(buf, &pDst[nDstLength], nLength);        // 转换该段数据到目标PDU串
      
        // 返回目标字符串长度
        return nDstLength;
    }
      
    // PDU解码,用于接收、阅读短消息
    // pSrc: 源PDU串指针
    // pDst: 目标PDU参数指针
    // 返回: 用户信息串长度
    int gsmDecodePdu(const char* pSrc, SM_PARAM* pDst)
    {
        int nDstLength;          // 目标PDU串长度
        unsigned char tmp;       // 内部用的临时字节变量
        unsigned char buf[256];  // 内部用的缓冲区
      
        // SMSC地址信息段
        gsmString2Bytes(pSrc, &tmp, 2);    // 取长度
        tmp = (tmp - 1) * 2;    // SMSC号码串长度
        pSrc += 4;              // 指针后移
        gsmSerializeNumbers(pSrc, pDst->SCA, tmp);    // 转换SMSC号码到目标PDU串
        pSrc += tmp;        // 指针后移
      
        // TPDU段基本参数、回复地址等
        gsmString2Bytes(pSrc, &tmp, 2);    // 取基本参数
        pSrc += 2;        // 指针后移
        if (tmp & 0x80)
        {
            // 包含回复地址,取回复地址信息
            gsmString2Bytes(pSrc, &tmp, 2);    // 取长度
            if (tmp & 1) tmp += 1;    // 调整奇偶性
            pSrc += 4;          // 指针后移
            gsmSerializeNumbers(pSrc, pDst->TPA, tmp);    // 取TP-RA号码
            pSrc += tmp;        // 指针后移
        }
      
        // TPDU段协议标识、编码方式、用户信息等
        gsmString2Bytes(pSrc, (unsigned char*)&pDst->TP_PID, 2);    // 取协议标识(TP-PID)
        pSrc += 2;        // 指针后移
        gsmString2Bytes(pSrc, (unsigned char*)&pDst->TP_DCS, 2);    // 取编码方式(TP-DCS)
        pSrc += 2;        // 指针后移
        gsmSerializeNumbers(pSrc, pDst->TP_SCTS, 14);        // 服务时间戳字符串(TP_SCTS)
        pSrc += 14;       // 指针后移
        gsmString2Bytes(pSrc, &tmp, 2);    // 用户信息长度(TP-UDL)
        pSrc += 2;        // 指针后移
        if (pDst->TP_DCS == GSM_7BIT)
        {
            // 7-bit解码
            nDstLength = gsmString2Bytes(pSrc, buf, tmp & 7 ? (int)tmp * 7 / 4 + 2 : (int)tmp * 7 / 4);  // 格式转换
            gsmDecode7bit(buf, pDst->TP_UD, nDstLength);    // 转换到TP-DU
            nDstLength = tmp;
        }
        else if (pDst->TP_DCS == GSM_UCS2)
        {
            // UCS2解码
            nDstLength = gsmString2Bytes(pSrc, buf, tmp * 2);        // 格式转换
            nDstLength = gsmDecodeUcs2(buf, pDst->TP_UD, nDstLength);    // 转换到TP-DU
        }
        else
        {
            // 8-bit解码
            nDstLength = gsmString2Bytes(pSrc, buf, tmp * 2);        // 格式转换
            nDstLength = gsmDecode8bit(buf, pDst->TP_UD, nDstLength);    // 转换到TP-DU
        }
      
        // 返回目标字符串长度
        return nDstLength;
    }
    

    依照GSM 07.05,发送短消息用AT+CMGS命令,阅读短消息用AT+CMGR命令,列出短消息用AT+CMGL命令,删除短消息用AT+CMGD命令。但AT+CMGL命令能够读出所有的短消息,所以我们用它实现阅读短消息功能,而没用AT+CMGR。下面是发送、读取和删除短消息的实现代码:

    // 发送短消息
    // pSrc: 源PDU参数指针
    BOOL gsmSendMessage(const SM_PARAM* pSrc)
    {
        int nPduLength;        // PDU串长度
        unsigned char nSmscLength;    // SMSC串长度
        int nLength;           // 串口收到的数据长度
        char cmd[16];          // 命令串
        char pdu[512];         // PDU串
        char ans[128];         // 应答串
      
        nPduLength = gsmEncodePdu(pSrc, pdu);    // 根据PDU参数,编码PDU串
        strcat(pdu, "/x01a");        // 以Ctrl-Z结束
      
        gsmString2Bytes(pdu, &nSmscLength, 2);    // 取PDU串中的SMSC信息长度
        nSmscLength++;        // 加上长度字节本身
      
        // 命令中的长度,不包括SMSC信息长度,以数据字节计
        sprintf(cmd, "AT+CMGS=%d/r", nPduLength / 2 - nSmscLength);    // 生成命令
      
        WriteComm(cmd, strlen(cmd));    // 先输出命令串
      
        nLength = ReadComm(ans, 128);   // 读应答数据
      
        // 根据能否找到"/r/n> "决定成功与否
        if (nLength == 4 && strncmp(ans, "/r/n> ", 4) == 0)
        {
            WriteComm(pdu, strlen(pdu));        // 得到肯定回答,继续输出PDU串
      
            nLength = ReadComm(ans, 128);       // 读应答数据
      
            // 根据能否找到"+CMS ERROR"决定成功与否
            if (nLength > 0 && strncmp(ans, "+CMS ERROR", 10) != 0)
            {
                return TRUE;
            }
        }
      
        return FALSE;
    }
      
    // 读取短消息
    // 用+CMGL代替+CMGR,可一次性读出全部短消息
    // pMsg: 短消息缓冲区,必须足够大
    // 返回: 短消息条数
    int gsmReadMessage(SM_PARAM* pMsg)
    {
        int nLength;        // 串口收到的数据长度
        int nMsg;           // 短消息计数值
        char* ptr;          // 内部用的数据指针
        char cmd[16];       // 命令串
        char ans[1024];     // 应答串
      
        nMsg = 0;
        ptr = ans;
      
        sprintf(cmd, "AT+CMGL/r");    // 生成命令
      
        WriteComm(cmd, strlen(cmd));    // 输出命令串
    
        nLength = ReadComm(ans, 1024);    // 读应答数据
    
        // 根据能否找到"+CMS ERROR"决定成功与否
        if (nLength > 0 && strncmp(ans, "+CMS ERROR", 10) != 0)
        {
            // 循环读取每一条短消息, 以"+CMGL:"开头
            while ((ptr = strstr(ptr, "+CMGL:")) != NULL)
            {
                ptr += 6;        // 跳过"+CMGL:"
                sscanf(ptr, "%d", &pMsg->index);    // 读取序号
      
                ptr = strstr(ptr, "/r/n");    // 找下一行
                ptr += 2;        // 跳过"/r/n"
      
                gsmDecodePdu(ptr, pMsg);    // PDU串解码
    
                pMsg++;        // 准备读下一条短消息
                nMsg++;        // 短消息计数加1
            }
        }
      
        return nMsg;
    }
      
    // 删除短消息
    // index: 短消息序号,从1开始
    BOOL gsmDeleteMessage(int index)
    {
        int nLength;          // 串口收到的数据长度
        char cmd[16];         // 命令串
        char ans[128];        // 应答串
      
        sprintf(cmd, "AT+CMGD=%d/r", index);    // 生成命令
      
        // 输出命令串
        WriteComm(cmd, strlen(cmd));
      
        // 读应答数据
        nLength = ReadComm(ans, 128);
      
        // 根据能否找到"+CMS ERROR"决定成功与否
        if (nLength > 0 && strncmp(ans, "+CMS ERROR", 10) != 0)
        {
            return TRUE;
        }
      
        return FALSE;
    }
    
    

    以上发送AT命令过程中用到了WriteComm和ReadComm函数,它们是用来读写串口的,依赖于具体的操作系统。在Windows环境下,除了用MSComm控件,以及某些现成的串口通信类之外,也可以简单地调用一些Windows API用实现。以下是利用API实现的主要代码,注意我们用的是超时控制的同步(阻塞)模式。

    // 串口设备句柄
    HANDLE hComm;
      
    // 打开串口
    // pPort: 串口名称或设备路径,可用"COM1"或"//./COM1"两种方式,建议用后者
    // nBaudRate: 波特率
    // nParity: 奇偶校验
    // nByteSize: 数据字节宽度
    // nStopBits: 停止位
    BOOL OpenComm(const char* pPort, int nBaudRate, int nParity, int nByteSize, int nStopBits)
    {
        DCB dcb;        // 串口控制块
        COMMTIMEOUTS timeouts = {    // 串口超时控制参数
            100,        // 读字符间隔超时时间: 100 ms
            1,          // 读操作时每字符的时间: 1 ms (n个字符总共为n ms)
            500,        // 基本的(额外的)读超时时间: 500 ms
            1,          // 写操作时每字符的时间: 1 ms (n个字符总共为n ms)
            100};       // 基本的(额外的)写超时时间: 100 ms
      
        hComm = CreateFile(pPort,    // 串口名称或设备路径
                GENERIC_READ | GENERIC_WRITE,    // 读写方式
                0,               // 共享方式:独占
                NULL,            // 默认的安全描述符
                OPEN_EXISTING,   // 创建方式
                0,               // 不需设置文件属性
                NULL);           // 不需参照模板文件
      
        if (hComm == INVALID_HANDLE_VALUE) return FALSE;        // 打开串口失败
      
        GetCommState(hComm, &dcb);        // 取DCB
      
        dcb.BaudRate = nBaudRate;
        dcb.ByteSize = nByteSize;
        dcb.Parity = nParity;
        dcb.StopBits = nStopBits;
      
        SetCommState(hComm, &dcb);        // 设置DCB
      
        SetupComm(hComm, 4096, 1024);     // 设置输入输出缓冲区大小
      
        SetCommTimeouts(hComm, &timeouts);    // 设置超时
      
        return TRUE;
    }
      
    // 关闭串口
    BOOL CloseComm()
    {
        return CloseHandle(hComm);
    }
      
    // 写串口
    // pData: 待写的数据缓冲区指针
    // nLength: 待写的数据长度
    void WriteComm(void* pData, int nLength)
    {
        DWORD dwNumWrite;    // 串口发出的数据长度
      
        WriteFile(hComm, pData, (DWORD)nLength, &dwNumWrite, NULL);
    }
      
    // 读串口
    // pData: 待读的数据缓冲区指针
    // nLength: 待读的最大数据长度
    // 返回: 实际读入的数据长度
    int ReadComm(void* pData, int nLength)
    {
        DWORD dwNumRead;    // 串口收到的数据长度
      
        ReadFile(hComm, pData, (DWORD)nLength, &dwNumRead, NULL);
      
        return (int)dwNumRead;
    }
    
    

    Q 在用AT命令同手机通信时,需要注意哪些问题?

    A 任何一个AT命令发给手机,都可能返回成功或失败。例如,用AT+CMGS命令发送短消息时,如果此时正好手机处于振铃或通话状态,就会返回一个"+CMS ERROR"。所以,应当在发送命令后,检测手机的响应,失败后重发。而且,因为只有一个通信端口,发送和接收不可能同时进行。

    如果串口通信用超时控制的同步(阻塞)模式,一般做法是专门将发送/接收处理封装在一个工作子线程内。因为代码较多,这里就不详细介绍了。所附的Demo中,包含了完整的子线程和发送/接收应用程序界面的源码。

    Q 以上AT命令,是不是所有厂家的手机都支持?

    A ETSI GSM 07.05规范直到1998年才形成最终Release版本(Ver 7.0.1),在这之前及之后一段时间内,不排除各厂商在DTE-DCE的短消息AT命令有所不同的可能性。我们用到的几个PDU模式下的AT命令,是基本的命令,从原则上讲,各厂家的手机以及GSM模块应该都支持,但可能有细微差别。

    Q 用户信息(TP-UD)内除了一般意义上的短消息,还可以是图片和声音数据。关于手机铃声和图片格式方面,有什么规范吗?

    A 为统一手机铃声、图片格式,Motorola和Ericsson, Siemens, Alcatel等共同开发了EMS(Enhanced Messaging Service)标准,并于2002年2月份公布。这些厂商格式相同。但另一手机巨头Nokia未参加标准的制定,手机铃声、图片格式与它们不同。所以没有形成统一的规范。EMS其实并没有超越GSM 07.05,只是TP-UD数据部分包含一定格式而已。各厂家的手机铃声、图片格式资料,可以查阅相关网站。

    Q 用户信息(TP-UD)其实可以是任何的自定义数据,是吗?

    A 是的,尽管手机上会显示乱码。这种情况下,编码方式已经没有任何意义。但注意仍然要遵守规范。比如,若指定7-bit编码方式,TP-UDL应等于实际数据长度的8/7(用进一法,而不是四舍五入)。在利用SMS进行点对点或多点对一点的数据通信的应用中,可以传输各种自定义数据,如GPS信息,环境监测信息,加密的个人信息,等等。

    如果在传输自定义数据的同时还要收发普通短消息,最简单的办法是在数据前面额外加个识别标志,比如"FFFF",以区分自定义数据和普通短消息。


    展开全文
  • AT指令框架的实现

    2020-02-05 07:00:51
    AT指令概述 AT指令是应用于终端设备与PC应用之间的连接与通信的指令。AT 即Attention。每个AT命令行中只能包含一条AT指令;对于AT指令的发送,除AT两个字符外,最多可以接收1056个字符的长度。 AT指令的格式 命令...

    AT指令概述

    AT指令是应用于终端设备与PC应用之间的连接与通信的指令。AT 即Attention。每个AT命令行中只能包含一条AT指令;对于AT指令的发送,除AT两个字符外,最多可以接收1056个字符的长度。

    AT指令的格式

    命令格式如下所示:

    AT[+CMD][=KEY]

    CMD:命令;
    KEY:参数的值,如果是?表示请求该参数的值,此处可有多个参数组成;

    用到的API函数简介

    char *strtok(char s[], const char *delim);

    分解字符串为一组字符串。s为要分解的字符,delim为分隔符字符(如果传入字符串,则传入的字符串中每个字符均为分割符)。首次调用时,s指向要分解的字符串,之后再次调用要把s设成NULL。

    int atoi(const char *nptr);

    atoi (表示 ascii to integer)是把字符串转换成整型数的一个函数,应用在计算机程序和办公软件中。int atoi(const char *nptr) 函数会扫描参数 nptr字符串,跳过前面的空白字符(例如空格,tab缩进)等,可以通过isspace( )函数来检测),直到遇上数字或正负符号才开始做转换,而在遇到非数字或字符串结束符('\0')才结束转换,并将结果返回。如果 nptr不能转换成 int 或者 nptr为空字符串,那么将返回 0。特别注意,该函数要求被转换的字符串是按十进制数理解的。

    AT指令框架设计思路

    好的代码应该具有良好的封装和可读性,AT指令解释器的设计主要通过二级链表针对AT指令的特征对指令进行分类,提高指令索引效率,通过回调函数实现代码的良好封装。其中一级数据结构如下所示:

    
    typedef  struct MemShell_t {//指令成员
        char *Map;//指令保存区域
        uint16_t MapLength;//Map的长度
        uint8_t begin;//指令的首地址
        uint8_t end;//指令的结束地址
        void(*CallBack)(char *,uint16_t);//回调函数
        struct MemShell_t *Next;//下一个节点
    }MemShell_t, *MemShell_pt;
    
    展开全文
  • GSM/GPRS芯片是手机中负责收发短信、拨打电话以及访问GPRS网络的核心器件。有方M660+为深圳有方公司生产的一款超小封装的GSM/GPRS工业无线模块,可以提供高品质的语音、短信、数据业务等功能,在各种工业和民用领域...

    GSM/GPRS芯片是手机中负责收发短信、拨打电话以及访问GPRS网络的核心器件。有方M660+为深圳有方公司生产的一款超小封装的GSM/GPRS工业无线模块,可以提供高品质的语音、短信、数据业务等功能,在各种工业和民用领域得到广泛的应用。

    有方M660+ GPRS模块的硬件设计

    硬件设计参考附件《M660+ 硬件设计指南》。

    需要注意的几点:

    1. 模块工作电压为3.5V~4.3V(推荐值3.9V),不是5V。

    2. 模块平时工作电流较小,但是在模块注册网络或者其他一些特殊情况下,电流可能瞬间达到1.8A,如果电源供电能力不足,电压瞬间下降严重,将可能导致模块工作异常,没有信号,无法收发短信等情况。建议采用大电流的开关电源芯片供电,如LM2596 DC-DC转换模块;对于移动式设备,采用一块3.7V锂离子电池则刚好可以满足要求;另外应在GPRS模块供电端附近增加大电容滤波,滤波电容大小见硬件设计指南。

      • 瞬间电流Max 1.8A
      • 平均工作电流 <300mA
      • 待机电流1.5mA typ

    3. 该模块使用3.3V 电平串口,即高电平为3.3V,不是5V,对于5V电平的单片机或TTL串口,为保证工作可靠,不至于烧坏芯片,最好按照硬件设计指南中电路图搭建电平转换电路。

    单片机系统的硬件设计

    通常使用较多的单片机有51、AVR、MSP430、STM32等。需要根据系统功能,考虑选择合适的单片机。

    51单片机使用5V电平,且多数型号RAM、ROM较小,运行速度较慢,适合做一些较简单的应用,优点是简便易学,且焊接容易(很容易买到使用DIP(直插式)封装的51单片机)。

    430单片机使用3.3V电平,与GPRS模块能很好的兼容,且配置相比51更好,最大的特点是低功耗,且性价比较高,适合做不需要处理大量数据(如多媒体信息处理,复杂的人机交互)的多数应用。缺点是大部分430采用贴片封装,不易于焊接,且使用不当容易烧坏芯片。

    STM32单片机基于ARM7内核,功能强大,功耗较低,性价比很高,但对于只接触过51一类单片机的人来说,不一定能很好的掌握,因为正是由于功能强大,导致其程序庞大,一些比较简单的应用不需要使用STM32。STM32适合开发一些需要处理一些图片、音频,以及用户可视化交互的系统。

    总体来说,推荐优先选用MSP430;如果应用比较简单,可使用51;如果需要一些较为复杂的数据处理,尤其是多媒体信息,可考虑使用STM32、ARM9及以上处理器,或者结合FPFA、DSP来实现。

    有方M660+ GPRS模块的软件设计

    从硬件层面来说,有方GPRS模块仅仅涉及了串口通信,硬件层的编程比较容易。初次接触GPRS模块编程时,比较难的是面向AT指令集协议编程(尤其是字符串处理很麻烦),以及如何编写高效,而又可靠健壮的程序。

    AT指令集是一种可用于GSM/GPRS模块的通信协议。何谓协议?举个简单的例子,我们说话过程中使用的语言,作为大家共同接受的标准,可以在我们之间传递信息,这就叫做协议。而串口则是一种接口,接口又是什么呢?接口就是收发信息的实现,我们的嘴巴和耳朵就相当于接口。

    接口和协议又有什么关系呢?串口作为接口,只能一个字节一个字节的传输字符,类似的,我们的嘴巴和耳朵原本也只能收发不同的声音。接口是具体实现,而协议则规定了接口传输的信息代表什么含义。如果没有接口,协议肯定没法实现,人没有嘴巴和耳朵是没法用声音交流的。另一方面,如果没有协议,或者协议不兼容,接口的实现也并不能代表什么含义。没有语言的话,两个人只是乱叫完全没法交流;如果两个人使用不同的语言,而且听不懂彼此的语言(相当于协议不兼容),也是同样不能交流的。

    在GPRS模块软件的开发中,接口的实现远比协议实现要简单。接口的实现在这里就不做介绍,这里主要探讨如何编写高效可靠的程序来实现GPRS模块的协议即AT指令集。

    完整的AT指令集请参考附件《AT命令手册》,这里只介绍一些基本用法。

    AT指令集的学习

    要想编写程序实现AT指令集的功能,就应该先学习AT指令集。如何学习AT指令集呢?一些人会直接给单片机写程序去控制GPRS模块的方式学习。事实上,这样很难学好AT指令集,往往会出现各种错误。当你对AT指令集不了解的情况下,盲目的去写程序,而又并不能保证程序没有错误按设想运行(如果你能保证这一点,那么你就是编程经验非常丰富的高手了,反正我是做不到这一点),这样的情况下,实验失败时,你根本没法确定是程序的问题还是AT指令集的问题,甚至有可能是硬件问题等等。

    于是,一般我们将GPRS模块连接到计算机上来学习AT指令集。对于大多数没有串口的计算机,你需要有个USB转TTL串口的转接线,即使有RS232串口,也需要通过一些转接芯片进行电平转换,转换成TTL串口。注意GPRS模块TTL串口的电平为3.3V,尽量使用电平转换电路以免电平不兼容烧坏GPRS模块。同时,你需要设计好GPRS模块的供电电路,给其提供一个稳定可靠的电压。然后插上一张可用的手机SIM卡,连接好电源和串口,GPRS模块上电后会和手机开机一样,需要数分钟的时间搜索信号,然后就可以正常工作。

    电脑端我们使用串口超级终端软件来调试GPRS模块。

    当我们从超级终端给GPRS模块发送“AT”,并按回车时,如果一切正常,屏幕上会显示返回的“OK”字符,这就是AT指令集最基本的操作:确认AT指令集工作正常。

    通过AT指令集初始化GPRS模块一般包括以下步骤(前面加“--”符号的表示正常工作返回的字符串,不同模块不完全一样,仅供参考,//表示注释):

    1. AT // 确认AT指令集工作正常
    2. --OK
    3. ATE0 // 关闭回显(即禁止GPRS模块发送接收到每一个的字符,在电脑上调试时不需此语句)
    4. --OK
    5. AT+CPIN // SIM卡准备好?
    6. --READY
    7. AT+CMGF=1 // 设置短消息格式为Text模式,需在模块上电一段时间后才能正常返回OK,在此之前会返回ERROR
    8. --OK
    9. AT+CSMP=17,167,0,0 // 设置Text模式参数,用于短信发送
    10. --OK
    11. AT+CSCS="GSM" // 设置GSM字符集,用于短信发送
    12. --OK
    13. AT+CREG? // 网络注册完成?应该一直循环发送此句直到网络注册完成才能进行短信和电话操作,如果没有信号,也会返回错误信息
    14. --+CREG: 0, 1, "341B", "2DBF"

    如果需要使用GPRS网络,也可以在此处初始化,或者在需要使用时才初始化。

    写程序时发送这些字符串要注意,在每一句结尾处应有一个"\r"结束标志(回车符,ASCII码中的13,常缩写为)。对于大部分指令,GPRS模块接收到此结束符才会执行指令。另外有些引号不可省略,在写程序时应写为转义字符。

    网络注册正常后,发送ATD10086,就会给10086打电话,返回OK说明正在尝试拨打,拨号成功或没有信号会返回相应字符串。拨号成功,如果连接了话筒和耳机,就能正常通话了。

    发送短信有两种方式,一种是TEXT模式,另一种是PDU模式,需要先设置好。其中TEXT模式只支持英文(不排除可能有些模块或者某些特别的方法能使其支持中文),PDU模式支持中文,但编码方式较为复杂。

    PDU可参考:http://yuanyu5237.iteye.com/blog/1126185

    注:文中提到一个字符ASCII码中的26(0x1A),在超级终端中可通过Ctrl+Z输入

    AT指令集协议的编程实现

    要编写一个高效而又可靠的程序,我们既要向GPRS模块发送数据,又需要接收返回的数据并判断返回值是否正确。

    发送数据可以调用串口发送函数直接发送,而接收数据时,需要接收一段完整的字符串。由于单片机可能正在处理其他任务,并不一定能马上响应接收的指令。编程时我们可以使用环形队列作为串口接收缓冲区,并在接收到"\r"结束符时置位一个接收标志,然后等待CPU处理。对于一些特殊情形,返回值并不是以"\r"结束,比如发送短信提示输入短信内容时是以">"结束,此时可以通过延时等待并不断查询的方式判断是否接收到正常的返回值。

    还有一种通过超时判断是否接收完一条指令的方法,效果相对比较好。当接收到第一个字符时,启动定时器计时,如果一定时间内接收到下一个字符,清零定时器,再次重新计时……当接收到某个字符之后,计时到超过一定时间仍未收到下一个字符,表明接收完一条指令。因为返回的每条指令都是连续发送出来的,间隔时间固定,所以这种方式能准确判断指令是否接收完成,缺点是会占用更多硬件资源(需要多用一个定时器)。

    为了充分实现代码复用,加快程序开发,可以考虑实现这样几个函数:

    1. // 字符串复制(可使用string.h中的标准函数)
    2. void StrCopy(char*, char*);
    3. // 判断一个字符串是否包含另一个字符串
    4. unsigned char StrContain(char*, char*);
    5. // 发送指令并等待返回指定字符串。注意如果超时仍未返回指定字符串,则应退出函数,以免死机
    6. unsigned char SendAndGet(char*, char*);
    7. // 发送指令并等待返回指定字符串,尝试n次
    8. unsigned char SendAndGetTimes(char*, char*, unsigned char);
    9. // 初始化AT指令集设备,返回初始化是否成功结果
    10. unsigned char AT_Init(void);
    11. // 发送短信,并返回发送是否成功标志
    12. unsigned char SendMsg(char*, char*);
    13. // 检测模块当前是否有信号
    14. unsigned char CheckSignal(void);

    一些更复杂的问题

    当先后间隔很短时间发送多条指令,或者是前一条指令需要GPRS模块使用较长时间去响应时,情况就变得比较复杂了。比如说,我们给出指令发送一条短信,一般可能在10秒左右时间发完,然后返回OK。而在返回OK之前,如果又需要发送另外一条指令,或者很不幸有人打电话来,处理起来就很麻烦了。再比如在间隔很短时间内接收到多条消息,前一条正在处理,后一条消息又被接收到,这个时候怎么保证不遗漏消息呢?我们可以考虑使用队列来解决这个问题。

    类似这样的问题很多,尤其对于速度低存储空间小的单片机来说也不太好解决,而对于一些简单应用也不一定要考虑这么多情况,本文不做详细探讨。

    附件

    串口超级终端 http://download.csdn.net/detail/jzj1993/5744509
    有方M660+硬件设计指南 http://download.csdn.net/detail/jzj1993/5507753
    AT命令手册 http://download.csdn.net/detail/jzj1993/5507747

    展开全文
  • AT指令集版本:0.40.0.0 SDK版本:1.3.0 二、实验目的使用ESP8266的AT指令查询标准北京时间API提供的北京时间。三、实验步骤(每条AT指令后均需要添加换行后再发送) 1. 使用串口发送指令AT+CWMODE=1设置模块Wi-Fi...
  • Q 用串口连接GSM手机发送和接收短消息,在应用程序中如何编程实现? Q 我们打算开发一个基于GSM短消息方式的GPS系统,如何利用SMS进行数据通信? A 首先,我们要对由ESTI制订的SMS规范有所了解。与我们讨论...
  • java发送短信之AT指令

    2020-07-29 14:21:47
    * 向串口发送AT指令 * @param atcommand 指令内容 * @return 指令返回结果 * @throws java.rmi.RemoteException */ public String sendAT(String atcommand) throws java.rmi.RemoteException { String s = ...
  • 通过串口收发短消息(上) 下载本文示例源代码 原文出处:http://www.kernelstudio.com/getitem.asp?id=13 Q 用串口连接GSM手机发送和接收短消息,在应用程序中如何编程实现? Q 我们打算开发一个基于...
  • AT指令介绍及用法

    2008-04-30 14:30:00
    AT 指令 AT 即Attention,AT指令集是从终端设备(Terminal Equipment,TE)或数据终端设备 (Data Terminal Equipment,DTE)向终端适配器(Terminal Adapter, TA)或数据电路终端设备 (Data Circuit Terminal ...
  • 今天看到了一个有关使用 ESP8266的AT指令 的HTTP连接的demo,因此想拿来一试, 访问API试一下,简单访问 心知天气 天气服务平台的地区天气接口测试一下 (万物基于API,你细品) 本文仅发布在CSDN 青云双青 和我的...
  • 最详细AT指令

    2016-03-12 22:37:13
    概述 手机的短消息实现目前有三种方法:  1.通过移动网关发送短消息,使用该方法不需要附加的硬件,但是需要到电信部门申请网关,比较适用于一些大型的网络通讯公司开发,目前华为,中兴等公司就做的这方面的工作,...
  • 0. 前言 网上这种东西不太多,我也是看了不少资料弄出来了,觉得应该写点东西出来...当然,不管你板子是什么,这篇文章主要讲的不是板子的问题,而是如何通过串口AT指令控制GA6-B这种支持GPRS的短信模块来实现MQT...
  • 我们要实现的功能是在程序运行的时候通过单片机串口串口调试助手发送一个字符串诸如“hello world”,串口通信助手接收到字符串之后显示并由用户反馈回去一个长度为4的字符串并显示到数码管上来看一下效果首先是...
  • 发送AT指令

    2014-06-05 15:06:55
    最近实验室在进行
  • 没有超长延时等待或死循环等待AT指令反馈,具体可参考以下介绍。 抛砖引玉,如果大家有更好的ESP8266 AT指令程序程序,欢迎多多交流,或者也可以在我这代码的基础上进行优化 也希望各位大神能指导指导我的代码格式...
  • AT+CMGC Send an SMS command(发出一条短消息命令)  AT+CMGD Delete SMS message(删除SIM卡内存的短消息)  AT+CMGF Select SMS message formate(选择短消息信息格式:0-PDU;1-文本)  AT+...
  • 上一篇使用USB转串口的方式通过ESP8266wifi模块的方式成功连接上了阿里云,现在就要通过单片机来替换电脑上位机了,这样单片机自动的去调用并发送串口数据更加方便,也更加符合一个产品的开发。板载的传感器有NTC...
1 2 3 4 5 ... 20
收藏数 1,069
精华内容 427
关键字:

单片机串口调用at指令