使用SerialPort 对象实现串口拨号器通信[上]

最新推荐文章于 2022-01-18 01:08:44 发布
最新推荐文章于 2022-01-18 01:08:44 发布
阅读量282 收藏
点赞数
原文链接：https://yq.aliyun.com/articles/381059
版权

首先，定义 CommandInfo 结构体

结构体 CommandInfo 用于保存当前 AT 指令的相关信息，代码如下：

复制代码 
    enum CommandDirection
    { 
       None = 0, 
       Read = 1, 
       Write = 2
    }

    enum CommandKey
    {
        None = 0, 
        AT = 1, 
        ATD = 2,
        ATH = 3,
        AT_CFUN = 4
    }

    struct CommandInfo
    {
        public CommandDirection TransType; // 写入 / 读取

        public CommandKey Command;     // 命令类型

        public int CommandLength;   // 命令自身长度 (不包含\r\n)

        public Byte[] SourceData;   // 数据源

        public int SourceDataLength;// 数据源长度 (包含\r\n 等转义字符)

        public int sleep100msNumber;// 延时100毫秒数
    }
复制代码

然后，定义拨号器 Modem 类

一个 Modem 对象表示一个拨号器，Modem 对象的成员、属性、委托、构造方法如下：

复制代码 
    private SerialPort m_port;
    private Boolean sending = false;
    private Boolean receiving;
    private string m_portName = "";   // 串口名称
    private int m_boudrate = 0;       // 波特率

    private SetCallback m_callBack = null; //返回委托事件
    
    #region 委托
    public delegate void SetCallback(String message);

    //委托返回信息
    private void ReturnMessage(String message)
    {
        if (message.Length > 0 && m_callBack != null)
        {
            m_callBack(message);
        }
    }
    #endregion

    #region  属性
    //串口名称
    public string PortName
    {
        get { return m_portName; }
        set { m_portName = value; }
    }

    // 串行波特率
    public int Boudrate
    {
        get 
        {
            if (0 == this.m_boudrate)
            {
                this.m_boudrate = this.DefaultBoudrate; //默认波特率
            }
            return m_boudrate; 
        }
        set { m_boudrate = value; }
    }

    // 默认串行波特率(只读)
    public virtual int DefaultBoudrate
    {
        get { return 9600; }
    }
    #endregion

    #region  构造方法
    public Modem(string _portName, int _baudRate, SetCallback _callBack)
        : this(_portName, _callBack)
    {
        if (_baudRate != 0)
        {
            this.m_boudrate = _baudRate;  // BaudRate 串行波特率
        }
    }

    public Modem(string _portName, SetCallback _callBack)
    {
        CreateModem(_portName);

        if (_callBack != null) m_callBack = _callBack;

        try
        {
            OpenModem();
        }
        catch
        {
            CloseModem();
        }

    }
    #endregion
复制代码

拨号器所对应的串口的基本方法如下：

复制代码 
    #region 拨号器的基本方法
    private void CreateModem(string portName)
    {
        if (this.m_port == null)
        {
            this.m_port = new SerialPort(portName, this.Boudrate, Parity.None, 8, StopBits.One);
            this.m_port.ReadTimeout = 50000; //50秒超时时间

            this.m_port.RtsEnable = true; // 是否启用请求发送 (RTS) 信号
            //Request To Send 是由计算机发送信号到联接的调制解调器，以请示允许发送数据。

            //this.m_port.DtrEnable = true; // 是否使(DTR)线有效。
            //Data Terminal Ready 是计算机发送到调制解调器的信号，指示计算机在等待接受传输。 

            this.PortName = portName;
        }
    }
    private void CreateModem()
    {
        if (this.m_port == null)
        {
            this.m_port = new SerialPort(this.PortName, this.Boudrate, Parity.None, 8, StopBits.One);
            this.m_port.ReadTimeout = 50000; //50秒超时时间

            this.m_port.RtsEnable = true; // 是否启用请求发送 (RTS) 信号
            //Request To Send 是由计算机发送信号到联接的调制解调器，以请示允许发送数据。

            //this.m_port.DtrEnable = true; // 是否使(DTR)线有效。
            //Data Terminal Ready 是计算机发送到调制解调器的信号，指示计算机在等待接受传输。 
        }
    }

    // Opening modem port
    public Boolean OpenModem()
    {
        CreateModem();
        try
        {
            if (!m_port.IsOpen)
            {
                this.m_port.Open();
            }
            return true;
        }
        catch (Exception ex)
        {
            //這邊你可以自訂發生例外的處理程序
            ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
            return false;
        }
    }


    // Closing modem port
    public void CloseModem()
    {
        try
        {
            if (!sending && this.m_port != null && this.m_port.IsOpen)
            {
                this.m_port.Close();
                //ReturnMessage("端口已关闭");
            }
        }
        catch (Exception ex)
        {
            //這邊你可以自訂發生例外的處理程序
            ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
        }
    }
    #endregion
复制代码

拨号器的 “发送命令” 和 “返回接受” 方法是整个Modem 对象的核心，代码如下：

复制代码 
    // 向端口发送命令
    private bool SendData(Object dataInfo)
    {
        if (dataInfo == null) return false;

        CommandInfo sourceInfo = (CommandInfo)dataInfo;

        string returnString = "";
        bool receiveSate = false;

        if (sourceInfo.SourceData != null)
        {
            Byte[] buffer = sourceInfo.SourceData;
            try
            {
                sending = true;
                m_port.Write(buffer, 0, buffer.Length);
                receiving = true;
                Thread.Sleep(200);

                //comport.DiscardInBuffer();    //清空输入缓冲区
                //comport.DiscardOutBuffer();   //清空输出缓冲区

                receiveSate = DoReceive(sourceInfo, ref returnString);

                //返回处理
                switch (sourceInfo.Command)
                {
                    case CommandKey.AT: // 处理 AT 指令
                        Process_AT_Command(returnString);
                        break;

                    case CommandKey.ATD: // 处理 ATD 指令
                        Process_ATD_Command(returnString);
                        break;

                    case CommandKey.ATH: // 处理 ATH 指令
                        Process_ATH_Command(returnString);
                        break;

                    case CommandKey.AT_CFUN: // 处理 AT_CFUN 指令
                        Process_AT_CFUN_Command(returnString);
                        break;

                    case CommandKey.None: //处理 其他未知 指令
                    default:
                        Process_None_Command(returnString);
                        break;
                }   
            }
            catch (Exception ex)
            {
                //这里你可以自定义发生例外的处理程序
                CloseModem();
                ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
            }
            finally
            {
                sending = false;
            }
        }

        return receiveSate;
    }


    // 接受端口返回数据
    private bool DoReceive(CommandInfo dataInfo, ref String returnString)
    {
        List<Byte> tempList = new List<Byte>();
        Byte[] buffer = new Byte[1024];
        Int32 ticks = 0;
        //string returnString = "";
        bool receiveSate = false;

        while (receiving)
        {
            Thread.Sleep(100);
            if (m_port.BytesToRead > 0)
            {
                try
                {
                    Int32 receivedLength = m_port.Read(buffer, 0, buffer.Length);
                    Array.Resize(ref buffer, receivedLength);
                    foreach (Byte item in buffer)
                    {
                        if (item != 0x0d && item != 0x0a)
                        {
                            tempList.Add(item);
                        }
                    }
                    //tempList.AddRange(buffer);
                    Array.Resize(ref buffer, 1024);
                }
                catch (TimeoutException timeEx)
                {
                    //這邊你可以自訂發生例外的處理程序
                    tempList.Clear();
                    m_port.DiscardInBuffer();    //清空输入缓冲区
                    receiving = false;
                    ReturnMessage(String.Format("读取超时:{0}", timeEx.ToString()));
                }
                catch (Exception ex)
                {
                    //這邊你可以自訂發生例外的處理程序
                    CloseModem();
                    receiving = false;
                    ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
                }
            }

            //返回字符 > 发送字符
            if (tempList.Count > dataInfo.CommandLength)
            {
                //（测试使用） 返回的所有字符串信息
                //string returnAllString = System.Text.Encoding.Default.GetString(tempList.ToArray()); 

                Byte[] returnByte = new Byte[tempList.Count - dataInfo.CommandLength];
                Array.Copy(tempList.ToArray(), dataInfo.CommandLength, returnByte, 0, returnByte.Length);

                //返回的字符串信息（剔除了发送字符）
                returnString = System.Text.Encoding.Default.GetString(returnByte).ToUpper();
                //returnString = System.Text.Encoding.Unicode.GetString(returnByte).ToUpper();
                receiving = false;
                receiveSate = true;  //表示成功接收返回
            }

            ticks++;
            if (ticks >= dataInfo.sleep100msNumber)
            {
                receiving = false;
                ReturnMessage("接收延时过久！");
            }
        }

        return receiveSate;

        //返回数据监听结束后的业务处理
        //ProcessReceive(dataInfo, returnString);
    }
复制代码

需要使用的 AT 指令定义的方法如下：

复制代码 
    // 检测当前端口是否安装有拨号器
    public bool CheckPortExistModem()
    {
        bool hasModem = false;

        if (!sending && OpenModem())
        {
            CommandInfo dataInfo = new CommandInfo();
            dataInfo.TransType = CommandDirection.Write;
            dataInfo.Command = CommandKey.AT;
            dataInfo.CommandLength = 2;
            dataInfo.SourceDataLength = 4;
            dataInfo.SourceData = ConvertStringToBytes("AT\r\n");
            dataInfo.sleep100msNumber = 10;

            //Thread t = CreateThread();
            //t.Start(dataInfo); //xg

            hasModem = SendData(dataInfo); //不使用多线程的方式
        }

        return hasModem;
    }


    // 发送拨号指令唤醒上位机
    public void DialingNumberToModem(string _number)
    {
        if (!sending && OpenModem())
        {
            CommandInfo dataInfo = new CommandInfo();
            dataInfo.TransType = CommandDirection.Write;
            dataInfo.Command = CommandKey.ATD;
            dataInfo.CommandLength = 15;
            dataInfo.SourceDataLength = 17;
            dataInfo.SourceData = ConvertStringToBytes(string.Format("ATD{0};\r\n", _number));
            dataInfo.sleep100msNumber = 500;

            //Thread t = CreateThread();
            //t.Start(dataInfo);

            SendData(dataInfo); //不使用多线程的方式
        }
    }

    // 发送挂机指令停止拨号
    private void StopDialingNumberToModem()
    {
        if (OpenModem())  // if (!sending && OpenModem())
        {
            CommandInfo dataInfo = new CommandInfo();
            dataInfo.TransType = CommandDirection.Write;
            dataInfo.Command = CommandKey.ATH;
            dataInfo.CommandLength = 3;
            dataInfo.SourceDataLength = 5;
            dataInfo.SourceData = ConvertStringToBytes("ATH\r\n");
            dataInfo.sleep100msNumber = 20;

            //Thread t = CreateThread();
            //t.Start(dataInfo);

            SendData(dataInfo); //不使用多线程的方式
        }
    }

    //重启拨号器
    private void RebootToModem()
    {
        if (OpenModem())  // if (!sending && OpenModem())
        {
            CommandInfo dataInfo = new CommandInfo();
            dataInfo.TransType = CommandDirection.Write;
            dataInfo.Command = CommandKey.AT_CFUN;
            dataInfo.CommandLength = 11;
            dataInfo.SourceDataLength = 15;  // AT+CFUN=1,1\r\nOK
            dataInfo.SourceData = ConvertStringToBytes("AT+CFUN=1,1\r\n");
            dataInfo.sleep100msNumber = 100;

            //Thread t = CreateThread();
            //t.Start(dataInfo);

            SendData(dataInfo); //不使用多线程的方式
        }
    }


private Byte[] ConvertStringToBytes(String dataString)

{


//if (Regex.IsMatch(dataString, "([^0-9a-fA-F])"))

//{

//    //表示有不符的字元

//    ReturnMessage("Block 数据错误");

//    return null;

//}


byte[] buff = Encoding.ASCII.GetBytes(dataString);

return buff;

}
复制代码

对应的 AT 指令返回数据处理如下：

复制代码 
        //处理 AT 指令
        private void Process_AT_Command(String returnString)
        {
            if (returnString == "OK")
            {
                //拨号器正常
                ReturnMessage(String.Format("AT指令正常，返回信息：{0}", returnString));
            }
            else
            {
                ReturnMessage(String.Format("AT指令异常，返回信息：{0}", 
                                     returnString != "" ? returnString : "无"));
            }
        }

        //处理 ATD 指令
        private void Process_ATD_Command(String returnString)
        {
            switch (returnString)
            {
                case "ERROR":  //当拨打电话不成功时，返回 ERROR
                case "NO DIALTONE": //未检测到拨号音，返回 NO DIALTONE
                    ReturnMessage(String.Format("返回信息：{0}，重启拨号器...", returnString));
                    RebootToModem(); //重启拨号器
                    break;

                case "NO CARRIER": //被叫方接通电话，然后主动挂机，信道已释放。返回 NO CARRIER
                    ReturnMessage(String.Format("返回信息：{0}", returnString));
                    break;

                case "BUSY":  //检测到占线信号,直接挂机。返回 BUSY 
                case "OK":    //当接通电话时，返回 OK 
                case "":
                default:
                    ReturnMessage(String.Format("返回信息：{0}，发送挂机指令...", 
                                         returnString != "" ? returnString : "无"));
                    StopDialingNumberToModem();  //发送挂机指令停止拨号 ATH
                    break;
            }
        }

        //处理 ATH 指令
        private void Process_ATH_Command(String returnString)
        {
            ReturnMessage(String.Format("已挂机，返回信息：{0}", 
                                 returnString != "" ? returnString : "无"));
        }

        //处理 AT_CFUN 指令
        private void Process_AT_CFUN_Command(String returnString)
        {
            if (returnString == "OK^SYSSTART")
            {
                //重启成功
                ReturnMessage(String.Format("拨号器重启成功，返回信息：{0}", returnString));
            }
            else ReturnMessage(String.Format("拨号器重启异常，返回信息：{0}", 
                                      returnString != "" ? returnString : "无"));
        }

        //处理 其他未知 指令
        private void Process_None_Command(String returnString)
        {
            ReturnMessage(String.Format("拨号器其他情况，返回信息：{0}", 
                                 returnString != "" ? returnString : "无"));
        }
复制代码

整个 Modem 类的代码如下：

Modem.cs 整体代码 
using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Threading;
using System.Windows.Forms;

namespace RequestResponse001CS
{
    public class Modem
    {
        private SerialPort m_port;
        private Boolean sending = false;
        private Boolean receiving;

        private string m_portName = "";   // 串口名称
        private int m_boudrate = 0;       // 波特率
        //private bool m_isWorking = false; // 是否正在使用
        //private string m_answer = "";     // 返回数据缓冲区
        //private DateTime lastUseTime = DateTime.MinValue; //最后一次使用时间

        private SetCallback m_callBack = null; //返回委托事件
        
        #region 委托
        public delegate void SetCallback(String message);

        //委托返回信息
        private void ReturnMessage(String message)
        {
            if (message.Length > 0 && m_callBack != null)
            {
                m_callBack(message);
            }
        }
        #endregion

        #region  属性

        //串口名称
        public string PortName
        {
            get { return m_portName; }
            set { m_portName = value; }
        }

        //是否正在使用
        //public bool IsWorking
        //{
        //    get { return m_isWorking; }
        //    set { m_isWorking = value; }
        //}

        // 串行波特率
        public int Boudrate
        {
            get 
            {
                if (0 == this.m_boudrate)
                {
                    this.m_boudrate = this.DefaultBoudrate; //默认波特率
                }
                return m_boudrate; 
            }
            set { m_boudrate = value; }
        }

        // 默认串行波特率(只读)
        public virtual int DefaultBoudrate
        {
            get { return 9600; }
        }

        // Modem answer to command (只读)
        //public string Answer
        //{
        //    get { return m_answer; }
        //}

        //当前拨号器能否使用 (解决连续使用拨号问题)
        //public bool EnableWork
        //{
        //    get
        //    {
        //        TimeSpan span = DateTime.Now - lastUseTime;
        //        return span.TotalSeconds >= 60;
        //    }
        //    //set { enableUse = value; }
        //}

        #endregion

        #region  构造方法
        public Modem(string _portName, int _baudRate, SetCallback _callBack)
            : this(_portName, _callBack)
        {
            if (_baudRate != 0)
            {
                this.m_boudrate = _baudRate;  // BaudRate 串行波特率
            }
        }

        public Modem(string _portName, SetCallback _callBack)
        {
            CreateModem(_portName);

            if (_callBack != null) m_callBack = _callBack;

            try
            {
                OpenModem();
            }
            catch
            {
                CloseModem();
            }

        }
        #endregion

        #region 拨号器的基本方法
        private void CreateModem(string portName)
        {
            if (this.m_port == null)
            {
                this.m_port = new SerialPort(portName, this.Boudrate, Parity.None, 8, StopBits.One);
                this.m_port.ReadTimeout = 50000; //50秒超时时间

                this.m_port.RtsEnable = true; // 是否启用请求发送 (RTS) 信号
                //Request To Send 是由计算机发送信号到联接的调制解调器，以请示允许发送数据。

                //this.m_port.DtrEnable = true; // 是否使(DTR)线有效。
                //Data Terminal Ready 是计算机发送到调制解调器的信号，指示计算机在等待接受传输。 

                this.PortName = portName;
            }
        }
        private void CreateModem()
        {
            if (this.m_port == null)
            {
                this.m_port = new SerialPort(this.PortName, this.Boudrate, Parity.None, 8, StopBits.One);
                this.m_port.ReadTimeout = 50000; //50秒超时时间

                this.m_port.RtsEnable = true; // 是否启用请求发送 (RTS) 信号
                //Request To Send 是由计算机发送信号到联接的调制解调器，以请示允许发送数据。

                //this.m_port.DtrEnable = true; // 是否使(DTR)线有效。
                //Data Terminal Ready 是计算机发送到调制解调器的信号，指示计算机在等待接受传输。 
            }
        }

        // Opening modem port
        public Boolean OpenModem()
        {
            CreateModem();
            try
            {
                if (!m_port.IsOpen)
                {
                    this.m_port.Open();
                }
                return true;
            }
            catch (Exception ex)
            {
                //這邊你可以自訂發生例外的處理程序
                ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
                return false;
            }
        }


        // Closing modem port
        public void CloseModem()
        {
            try
            {
                if (!sending && this.m_port != null && this.m_port.IsOpen)
                {
                    this.m_port.Close();
                    //ReturnMessage("端口已关闭");
                }
            }
            catch (Exception ex)
            {
                //這邊你可以自訂發生例外的處理程序
                ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
            }
        }
        #endregion

        #region 所有发送命令方法 commands method

        // 检测当前端口是否安装有拨号器
        public bool CheckPortExistModem()
        {
            bool hasModem = false;

            if (!sending && OpenModem())
            {
                CommandInfo dataInfo = new CommandInfo();
                dataInfo.TransType = CommandDirection.Write;
                dataInfo.Command = CommandKey.AT;
                dataInfo.CommandLength = 2;
                dataInfo.SourceDataLength = 4;
                dataInfo.SourceData = ConvertStringToBytes("AT\r\n");
                dataInfo.sleep100msNumber = 10;

                //Thread t = CreateThread();
                //t.Start(dataInfo); //xg

                hasModem = SendData(dataInfo); //不使用多线程的方式
            }

            return hasModem;
        }


        // 发送拨号指令唤醒上位机
        public void DialingNumberToModem(string _number)
        {
            if (!sending && OpenModem())
            {
                CommandInfo dataInfo = new CommandInfo();
                dataInfo.TransType = CommandDirection.Write;
                dataInfo.Command = CommandKey.ATD;
                dataInfo.CommandLength = 15;
                dataInfo.SourceDataLength = 17;
                dataInfo.SourceData = ConvertStringToBytes(string.Format("ATD{0};\r\n", _number));
                dataInfo.sleep100msNumber = 500;

                //Thread t = CreateThread();
                //t.Start(dataInfo);

                SendData(dataInfo); //不使用多线程的方式
            }
        }

        // 发送挂机指令停止拨号
        private void StopDialingNumberToModem()
        {
            if (OpenModem())  // if (!sending && OpenModem())
            {
                CommandInfo dataInfo = new CommandInfo();
                dataInfo.TransType = CommandDirection.Write;
                dataInfo.Command = CommandKey.ATH;
                dataInfo.CommandLength = 3;
                dataInfo.SourceDataLength = 5;
                dataInfo.SourceData = ConvertStringToBytes("ATH\r\n");
                dataInfo.sleep100msNumber = 20;

                //Thread t = CreateThread();
                //t.Start(dataInfo);

                SendData(dataInfo); //不使用多线程的方式
            }
        }

        //重启拨号器
        private void RebootToModem()
        {
            if (OpenModem())  // if (!sending && OpenModem())
            {
                CommandInfo dataInfo = new CommandInfo();
                dataInfo.TransType = CommandDirection.Write;
                dataInfo.Command = CommandKey.AT_CFUN;
                dataInfo.CommandLength = 11;
                dataInfo.SourceDataLength = 15;  // AT+CFUN=1,1\r\nOK
                dataInfo.SourceData = ConvertStringToBytes("AT+CFUN=1,1\r\n");
                dataInfo.sleep100msNumber = 100;

                //Thread t = CreateThread();
                //t.Start(dataInfo);

                SendData(dataInfo); //不使用多线程的方式
            }
        }


        //private Thread CreateThread()
        //{
        //    Thread t = new Thread(SendData);
        //    t.IsBackground = true;
        //    return t;
        //}


        // 向端口发送命令
        private bool SendData(Object dataInfo)
        {
            if (dataInfo == null) return false;

            CommandInfo sourceInfo = (CommandInfo)dataInfo;

            string returnString = "";
            bool receiveSate = false;

            if (sourceInfo.SourceData != null)
            {
                Byte[] buffer = sourceInfo.SourceData;
                try
                {
                    sending = true;
                    m_port.Write(buffer, 0, buffer.Length);
                    receiving = true;
                    Thread.Sleep(200);

                    //comport.DiscardInBuffer();    //清空输入缓冲区
                    //comport.DiscardOutBuffer();   //清空输出缓冲区

                    receiveSate = DoReceive(sourceInfo, ref returnString);

                    //返回处理
                    switch (sourceInfo.Command)
                    {
                        case CommandKey.AT: // 处理 AT 指令
                            Process_AT_Command(returnString);
                            break;

                        case CommandKey.ATD: // 处理 ATD 指令
                            Process_ATD_Command(returnString);
                            break;

                        case CommandKey.ATH: // 处理 ATH 指令
                            Process_ATH_Command(returnString);
                            break;

                        case CommandKey.AT_CFUN: // 处理 AT_CFUN 指令
                            Process_AT_CFUN_Command(returnString);
                            break;

                        case CommandKey.None: //处理 其他未知 指令
                        default:
                            Process_None_Command(returnString);
                            break;
                    }   
                }
                catch (Exception ex)
                {
                    //这里你可以自定义发生例外的处理程序
                    CloseModem();
                    ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
                }
                finally
                {
                    sending = false;
                }
            }

            return receiveSate;
        }

        // 接受端口返回数据
        private bool DoReceive(CommandInfo dataInfo, ref String returnString)
        {
            List<Byte> tempList = new List<Byte>();
            Byte[] buffer = new Byte[1024];
            Int32 ticks = 0;
            //string returnString = "";
            bool receiveSate = false;

            while (receiving)
            {
                Thread.Sleep(100);
                if (m_port.BytesToRead > 0)
                {
                    try
                    {
                        Int32 receivedLength = m_port.Read(buffer, 0, buffer.Length);
                        Array.Resize(ref buffer, receivedLength);
                        foreach (Byte item in buffer)
                        {
                            if (item != 0x0d && item != 0x0a)
                            {
                                tempList.Add(item);
                            }
                        }
                        //tempList.AddRange(buffer);
                        Array.Resize(ref buffer, 1024);
                    }
                    catch (TimeoutException timeEx)
                    {
                        //這邊你可以自訂發生例外的處理程序
                        tempList.Clear();
                        m_port.DiscardInBuffer();    //清空输入缓冲区
                        receiving = false;
                        ReturnMessage(String.Format("读取超时:{0}", timeEx.ToString()));
                    }
                    catch (Exception ex)
                    {
                        //這邊你可以自訂發生例外的處理程序
                        CloseModem();
                        receiving = false;
                        ReturnMessage(String.Format("出现异常:{0}", ex.ToString()));
                    }
                }

                //返回字符 > 发送字符
                if (tempList.Count > dataInfo.CommandLength)
                {
                    //（测试使用） 返回的所有字符串信息
                    //string returnAllString = System.Text.Encoding.Default.GetString(tempList.ToArray()); 

                    Byte[] returnByte = new Byte[tempList.Count - dataInfo.CommandLength];
                    Array.Copy(tempList.ToArray(), dataInfo.CommandLength, returnByte, 0, returnByte.Length);

                    //返回的字符串信息（剔除了发送字符）
                    returnString = System.Text.Encoding.Default.GetString(returnByte).ToUpper();
                    //returnString = System.Text.Encoding.Unicode.GetString(returnByte).ToUpper();
                    receiving = false;
                    receiveSate = true;  //表示成功接收返回
                }

                ticks++;
                if (ticks >= dataInfo.sleep100msNumber)
                {
                    receiving = false;
                    ReturnMessage("接收延时过久！");
                }
            }

            return receiveSate;

            //返回数据监听结束后的业务处理
            //ProcessReceive(dataInfo, returnString);
        }

        //处理 AT 指令
        private void Process_AT_Command(String returnString)
        {
            if (returnString == "OK")
            {
                //拨号器正常
                ReturnMessage(String.Format("AT指令正常，返回信息：{0}", returnString));
            }
            else
            {
                ReturnMessage(String.Format("AT指令异常，返回信息：{0}", 
                                     returnString != "" ? returnString : "无"));
            }
        }

        //处理 ATD 指令
        private void Process_ATD_Command(String returnString)
        {
            switch (returnString)
            {
                case "ERROR":  //当拨打电话不成功时，返回 ERROR
                case "NO DIALTONE": //未检测到拨号音，返回 NO DIALTONE
                    ReturnMessage(String.Format("返回信息：{0}，重启拨号器...", returnString));
                    RebootToModem(); //重启拨号器
                    break;

                case "NO CARRIER": //被叫方接通电话，然后主动挂机，信道已释放。返回 NO CARRIER
                    ReturnMessage(String.Format("返回信息：{0}", returnString));
                    break;

                case "BUSY":  //检测到占线信号,直接挂机。返回 BUSY 
                case "OK":    //当接通电话时，返回 OK 
                case "":
                default:
                    ReturnMessage(String.Format("返回信息：{0}，发送挂机指令...", 
                                         returnString != "" ? returnString : "无"));
                    StopDialingNumberToModem();  //发送挂机指令停止拨号 ATH
                    break;
            }
        }

        //处理 ATH 指令
        private void Process_ATH_Command(String returnString)
        {
            ReturnMessage(String.Format("已挂机，返回信息：{0}", 
                                 returnString != "" ? returnString : "无"));
        }

        //处理 AT_CFUN 指令
        private void Process_AT_CFUN_Command(String returnString)
        {
            if (returnString == "OK^SYSSTART")
            {
                //重启成功
                ReturnMessage(String.Format("拨号器重启成功，返回信息：{0}", returnString));
            }
            else ReturnMessage(String.Format("拨号器重启异常，返回信息：{0}", 
                                      returnString != "" ? returnString : "无"));
        }

        //处理 其他未知 指令
        private void Process_None_Command(String returnString)
        {
            ReturnMessage(String.Format("拨号器其他情况，返回信息：{0}", 
                                 returnString != "" ? returnString : "无"));
        }

        //处理监听返回业务
        //private void ProcessReceive(CommandInfo dataInfo, String returnString)
        //{
               
        //}


        private Byte[] ConvertStringToBytes(String dataString)
        {

            //if (Regex.IsMatch(dataString, "([^0-9a-fA-F])"))
            //{
            //    //表示有不符的字元
            //    ReturnMessage("Block 数据错误");
            //    return null;
            //}

            byte[] buff = Encoding.ASCII.GetBytes(dataString);
            return buff;
        }


        /// <summary>
        /// 直接向端口发送命令！
        /// </summary>
        /// <param name="command">命令字符串</param>
        private void SendCommandToModem(string command)
        {
            if (!this.m_port.IsOpen) this.OpenModem();

            byte[] buff = Encoding.ASCII.GetBytes(command);
            try
            {
                this.m_port.Write(buff, 0, buff.Length);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        #endregion
    }
}

最后，定义 FormModem 测试页面

测试页面 FormModem 代码如下：

复制代码 
using System;
using System.Windows.Forms;

namespace RequestResponse001CS
{
    public partial class FormModem : Form
    {
        public FormModem()
        {
            InitializeComponent();
        }

        Modem modem;
        private Modem.SetCallback call;

        private void Form1_Load(object sender, EventArgs e)
        {
            //sending = false;
            call = new Modem.SetCallback(this.TakeControl);
            modem = new Modem("COM8", call);
        }


        public void TakeControl(string message)
        {
            if (this.InvokeRequired)
            {
                Modem.SetCallback d = new Modem.SetCallback(TakeControl);
                this.Invoke(d, new object[] { message });
            }
            else
            {
                //MessageBox.Show(message);
                this.txtMessageShow.Text = this.txtMessageShow.Text + message + "\r\n";

                this.txtMessageShow.Select(this.txtMessageShow.Text.Length, 0);
                this.txtMessageShow.ScrollToCaret(); 
            }
        }


        private void Button_AT_Click(object sender, EventArgs e)
        {
            modem.CheckPortExistModem();
        }

        private void Button_ATD_Click(object sender, EventArgs e)
        {
            if (TextBox1.Text.Trim() != "")
            {
                modem.DialingNumberToModem(TextBox1.Text.Trim());
            }
            else modem.DialingNumberToModem("135xxxxxxxxxxx");
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            modem.CloseModem();
        }

    }
}
复制代码

测试页面截图如下：




本文转自钢钢博客园博客，原文链接：http://www.cnblogs.com/xugang/archive/2013/05/13/3075892.html，如需转载请自行联系原作者
weixin_34186128
关注
使用Serial Port类进行PC和其他设备的串口通讯
weixin_42569919的博客
04-30 921
如果大家网上看了一些资料就知道，vs做串口通讯有好几种方式，笔者只完成了SerialPort类的尝试。接下来简短的说一下我的步骤和心得吧，希望对新手有所帮助。 我最近要做PC和stm32通讯，只需要PC能发送数据到串口给stm32读就可以了，笔者也是萌新，一步步看博客过来，最后发现还是官网给的历程最有用。 地址：https://docs.microsoft.com/zh-cn/dotnet/api...
serialport通过usb通讯_使用SerialPort库进行Node物联网项目开发
weixin_32818577的博客
01-25 1151
如果说Nodejs将JavaScript的应用从网页端扩展到了服务器和操作系统端，Electron为JavaScript实现了跨平台应用的能力，那么SerialPort就是打通JavaScript软件与硬件的关键部件。著名的Johnny-Five物联网平台开发包的核心部件就是SerialPort,而Mozilla的WebThingsGateway物联网关也是在SerialPort基础上实现的。这是...
SerialPort 控件测试Modem AT 拨号指令
04-23
SerialPort 控件测试Modem AT 拨号指令
使用SerialPort 对象实现串口拨号器通信[下]
weixin_34239169的博客
05-13 120
  定义 ModemManager 调度管理类 ModemManager 类用于对所有 Modem 对象进行管理和调度使用。ModemManager 类代码如下： using System; using System.Collections.Generic; using System.Text; using System.IO.Ports; using System.Thre...
关于利用android-serialport-api实现在安卓设备上进行串口通信，附精简版demo，亲测可用。
热门推荐
写下半生程序
07-15 1万+
之前在网上找过，都不行，故自行下载google源码，弄了一个精简版
使用SerialPort对象实现串口拨号器通信Demo
05-14
这个"使用SerialPort对象实现串口拨号器通信Demo"是一个实例，展示了如何通过编程控制串口拨号器进行电话拨打。 首先，我们需要了解`System.IO.Ports.SerialPort`类。它是.NET框架的一部分，提供了与串行端口交互的...
使用SerialPort对象实现串口拨号器通信
05-13
在处理拨号器通信时，我们可能还需要解析返回的AT命令响应，比如检查是否成功建立连接，或者根据特定的回应执行下一步操作。 总之，使用C#的`SerialPort`类与串口设备通信涉及配置串口参数、发送和接收数据，以及...
python编写串口通信上位机_python实现读取串口数据，并写入数据库
weixin_39524834的博客
11-25 911
说明：本代码经本人测试，stm89c51等开发板传感器采集数据发送到串口，实现读取并写入数据库,不懂之处大家留言，看见会及时回复大家。问题咨询及项目源码下载请加群：群名：IT项目交流群群号：245022761import serialimport pymysql # 导入pymysql包# import easyguilog=0ser = serial.Serial()ser.baudrate =...
带串口功能，集成AT命令的串口拨号工具，附带android源码工程
05-30
总的来说，这个压缩包提供的源码工程对于理解Android平台上的串口通信、AT命令的使用以及拨号功能的实现具有重要意义。无论是对于嵌入式开发者还是Android应用开发者，深入研究这个项目都将有助于提升相关技能，并为...
C#串口通信全解析：.NET 2.0命名空间与实例
创建C#串口通信程序需要对.NET框架的System.IO.Ports API有深入理解，包括SerialPort类的使用、串口通信的帧结构以及硬件连接的配置。通过实际的代码示例，开发者可以轻松上手并应用于各种实际项目中，比如工业自动...
PPP协议串口 拨号 TCP HTTP协议
01-15
PPP协议串口 拨号 TCP HTTP协议
串口与Modem拨号
03-11
利用MSCOMM控件，通过串口发送AT指令来操作MODEM,是两台计算机通过公用电话网进行数据传输。
源代码C ATD拨打电话
02-27
本程序运行后如果gprs模块找到服务商信号，就拨打指定电话。51单片机的串口1连接到GSM 猫的tx rx gnd来拨打电话,
serialport通过usb通讯_IOT串口通讯-RS232/RS485
weixin_39702559的博客
01-25 1587
串口　 串口是串行接口(serial port)的简称，也称为串行通信接口或COM接口。串口通信是指采用串行通信协议(serial communication)在一条信号线上将数据一个比特一个比特地逐位进行传输的通信模式。串口按电气标准及协议来划分，包括RS-232-C、RS-422、RS485等. RS232 与 RS485 一直是弱电常见的接口。RS232与RS485在嵌入式中的实践一、RS2...
SIM800C通过串口AT指令拨打电话与发送短信
hus5487的博客
01-18 1万+
一、时间：2022.1.17 二、相关器件：CH340、SIM800C 三、硬件连接： 四、事件：通过CH340与SIM800C连接后，电脑使用串口调试助手发送AT指令控制SIM800C发送短信。 五、步骤： 1.上电后电源指示灯常亮，后等待SIM800C指示灯由快闪变为慢闪代表注册成功。 2.波特率115200，发送AT会返回AT代表握手成功(AT后加回车，之后指令也是)。 3.发送AT+CPIN?查询SIM800C是否读到卡，返回+CPI...
SerialPort 类
ruoshuixx的专栏
05-15 1617
SerialPort 类 .NET Framework 4.6 and 4.5 其他版本 表示串行端口资源。 继承层次结构 System.Object    System.MarshalByRefObject     System.ComponentModel.Component
c# com通讯类 用的是 SerialPort 类
ljl_xyf的专栏
04-28 755
using System; using System.Collections.Generic; using System.Text; using System.IO.Ports; using System.ComponentModel; using System.Threading;   namespace Cserver {     class ToCom 
SerialPort类的用法与示例
xiaoshihd的博客
03-26 1万+
SerialPort类的用法与示例 文章目录SerialPort类的用法与示例1. 串口硬件信号定义2. 串口端口号搜索3. 串口属性参数设置4. 串口发送信息5. 串口接收信息串口工具类串口使用注意事项 从Microsoft .Net 2.0版本以后，就默认提供了System.IO.Ports.SerialPort类，用户可以非常简单地编写少量代码就完成串口的信息收发程序。本文将介绍如何在PC端用C# .Net 来开发串口应用程序。 1. 串口硬件信号定义 DB9 Connector 信号定义
.NET 2.0中串口通讯类SerialPort
10-25 2060
1。简介随着USB的流行，串口通讯已经应用到日常生活的很多方面了，USB是一种高速的串口通讯协议，USB接口非常复杂，通常被用在需要传输大量数据数据的地方，如U盘、相机、打印机等。除了USB这种较为奢侈的串口外，在工控和嵌入式行业，大量被使用的是另一种古老的串口协议，RS-232串口。RS-232是一种非常简洁的低速串口通讯接口，它可以同时进行数据接收和发送的工作。2。.NET 2.0对串
C# SerialPort控件实现串口通信实例
串口通信是一种古老的但依然广泛使用的通信方式，特别是在硬件设备没有内置网络接口或者需要在没有网络连接的情况下进行数据传输时。C# SerialPort 类允许开发者轻松地控制串口设备，进行数据发送和接收。 在开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值