激发学习C,所以暂时不标明出处

作者: 编程  发布:2019-11-21

//注释:本文非原著是通过网上的代码修改大约10%而成的,忘了出处了,所以暂时不标明出处

一个C#资源分享平台,专业分享学习高质量代码,每周期布置学习任务,激发学习C#兴趣!(QQ群:128874886) 

//转化的工具类

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

关于C#操作短信猫的文章在博客园也有很多,其中个人认为比较专业的就是给我一杯酒 的短信猫软件实现的系列博客了!

namespace IntegrationSystemChemicalIndustry.Product
{
/// <summary>
  /// 阿拉伯数字转中文数字,中文数字转阿拉伯数字。
  /// by hcling97.Net 2007.03
  /// </summary>
public class NumberConventer
{
private string[] ArabinNum = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
private string[] ChnNum = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "拾", "佰", "仟", "万", "亿" };

短信猫软件的实现(C#)<一>熟悉串口

private string[] Union = { "", "拾", "佰", "仟" };
public NumberConventer()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
public string ArabToChn(Decimal ArabNum, out string msg)
{
string neg = string.Empty;
neg = (ArabNum < 0) ? "负" : "";
string result = string.Empty;
string[] part =
(ArabNum.ToString().Replace("-", string.Empty)).Split('.');
Int64 temp = Convert.ToInt64(part[0]);
Int64 epart = temp;
string dotpart =
(part.Length > 1) ? part[1] : string.Empty;
if (part.Length > 1)
{
dotpart = this.GetDotPart(dotpart);
}
string tmp = string.Empty;
string lasttemp = string.Empty;
for (int i = 0; i <= ((epart.ToString().Length - 1) / 4); i++)
{
int thousand = 0;
thousand = Convert.ToInt32(temp %
10000);
temp = temp / 10000;
lasttemp = tmp;
tmp = this.GetThousandPart(thousand);

短信猫软件的实现(C#)<二> AT指令调试器的简单实现

if (i == 0)
{
result = tmp;
lasttemp = tmp;
}
if (i == 1)//返回的是万
{
if (result == "零")
{
result = string.Empty;
}
result = tmp + "万" +
((lasttemp.IndexOf("千") == -1 && lasttemp != "零") ? "零" : "") + result;
}
if (i == 2)//亿
{
if (result.IndexOf("零万") != -1)
{

短信猫软件的实现(C#)<三>PDU格式短信解析

result = result.Replace("零万", string
.Empty);
}
result = tmp + "亿" + ((lasttemp.IndexOf("千") == -1 && lasttemp != "零") ? "零" : "") + result;
}
if (i == 3)//万亿
{
if (result.IndexOf("零亿") != -1)
{
result = result.Replace("零亿", "亿");
}
result = tmp + "万" + ((lasttemp.IndexOf("千") == -1 && lasttemp != "零") ? "零" : "") + result;
}
if (i == 4)//亿亿
{
if (result.IndexOf("零万") != -1)
{

短信猫软件的实现(C#)<四>PDU格式编码C#实现

result = result.Replace("零万", string
.Empty);
}
result = tmp + "亿" + ((lasttemp.IndexOf("千") == -1 && lasttemp != "零") ? "零" : "") + result;
}
}
result = neg + result + dotpart;
msg = "成功转换!";
return result;
}
/// <summary>
/// 处理小数部分
/// </summary>
/// <param name="dotPart"></param>
/// <returns></returns>
private string GetDotPart(string dotPart)
{
string result = "点";
for (int i = 0; i < dotPart.Length; i++)
{
result += ChnNum[Convert.ToInt32(dotPart[i].ToString())];
}
for (int j = 0; j < result.Length; j++)
//去除无效零或点
{

短信猫软件的实现(C#)<五>PDU格式解码C#实现

if (result[result.Length - j - 1].ToString() != "点" && result[result.Length - j - 1].ToString() != "零")
{
break;
}
else
{
result =result.Substring(0, (result.Length - j - 1));
}
}
return result;
}
/// <summary>
    /// 万位以下的分析
    /// </summary>
    /// <returns></returns>
private string GetThousandPart(int number)
{
if (number == 0)
{
return "零";
}
string result = string.Empty;
bool lowZero = false;
//记录低位有没有找到非零值,没找到置true
bool befZero = false;
//记录前一位是不是非零值,是0则置true
int temp = number;
int index = number.ToString().Length;
for (int i = 0; i < index; i++)
{
int n = temp % 10;
temp = temp / 10;
if (i == 0) //起始位
{
if (n == 0)
{
lowZero = true; //低位有0
befZero = true; //前位为0
}
else
{
result = ChnNum[n];
}
}
else
{
if (n != 0)
{
result = ChnNum[n] + Union[i] + result;
lowZero = false;
befZero = false;
}
else
{
if (!lowZero)
{
if (!befZero)
//低位有数,且前位不为0,本位为0填零
//eg.5906
{
result = ChnNum[n] + result;
befZero = true;
}
else
//低位有数,且前位为0省略零eg. 5008
{
}
}
else //低位为0
{
if (!befZero)//理论上不存在eg 5080
{
result = ChnNum[n] + result;
befZero = true;
}
else //eg. 5000
{
}
}
}
}
}
return result;
}
public Decimal ChnToArab(string ChnNum)
{
Decimal result = 0;
string temp = ChnNum;
bool neg = false;
if (ChnNum.IndexOf("负") != -1)
{
neg = true;
temp = temp.Replace("负", string.Empty);
}
string pre = string.Empty;
string abo = string.Empty;
9159.com,temp = temp.Replace("点", ".");
string[] part = temp.Split('.');
pre = part[0];
Decimal dotPart = 0;
if (part.Length > 1)
{
abo = part[1];
dotPart = this.GetArabDotPart(abo);
}

短信猫软件的实现(C#)<六>发送接收短信C#实现(API)

int yCount = 0;
//"亿"的个数,有可能出现亿亿。
//int yPos = 0;

短信猫软件的实现(C#)<七>短信猫(简化测试版)实现

int index = 0;
while (index < pre.Length)
{
if (pre.IndexOf("亿", index) != -1)
{
yCount++;
//yPos = pre.IndexOf("亿",index);
index = pre.IndexOf("亿", index) + 1;
}
else
{
break;
}
}
if (yCount == 2)//亿亿
{
pre = pre.Replace("亿", ",");
string[] sp = pre.Split(',');
result =
(neg ? -1 : 1) * ((this.HandlePart(sp[0]) * 10000000000000000) + (this.HandlePart(sp[1]) * 100000000) + this.HandlePart(sp[2])) + dotPart;
}
else
{
if (yCount == 1)
{
pre = pre.Replace("亿", ",");
string[] sp = pre.Split(',');
result =(neg ? -1 : 1) * ((this.HandlePart(sp[0]) * 100000000) + this.HandlePart(sp[1])) + dotPart;
}
else
{
if (yCount == 0)
{
result =(neg ? -1 : 1) * this.HandlePart(pre) + dotPart;
}
}
}
return result;

短信猫软件的实现(C#)<八>7bitPDU的解码

}
/// <summary>
    /// 处理亿以下内容。
    /// </summary>
    /// <param name="num"></param>
    /// <returns></returns>
private Decimal HandlePart(string num)
{
Decimal result = 0;
string temp = num;
temp = temp.Replace("万", ",");
string[] part = temp.Split(',');
for (int i = 0; i < part.Length; i++)
{
result +=Convert.ToDecimal(this.GetArabThousandPart(part[part.Length - i - 1])) * Convert.ToDecimal((System.Math.Pow(10000, Convert.ToDouble(i))));
}
return result;
}

短信猫软件的实现(C#)<九>7bitPDU的编码

/// <summary>
    /// 取得阿拉伯数字小数部分。
    /// </summary>
    /// <returns></returns>
private Decimal GetArabDotPart(string dotpart)
{
Decimal result = 0.00M;
string spe = "0.";
for (int i = 0; i < dotpart.Length; i++)
{
spe +=this.switchNum(dotpart[i].ToString()).ToString();
}
result = Convert.ToDecimal(spe);
return result;
}

短信猫软件的实现(C#)<十>类库(API)完善

public int GetArabThousandPart(string number)
{

短信猫软件的实现(C#)<十一>软件实现(完结篇)

string ChnNumString = number;
if (ChnNumString == "零")
{
return 0;
}
if (ChnNumString != string.Empty)
{
if (ChnNumString[0].ToString() == "十")
{
ChnNumString = "一" + ChnNumString;
}
}

非常感谢该作者给我们无私的分享和解答,在使用的过程中,还是发现一些问题,短信发不出去,找来找去终于找到原因,我用的是深圳百亿科技的GSM短信猫,他有自己的一些特殊规定,AT命令通用,但是求长度这一块好像不一样,下面就是我修正过来的短信猫操作类,增加了打电话,获取所有信息等方法!

ChnNumString = ChnNumString.Replace("零", string.Empty);
//去除所有的零
int result = 0;
int index = ChnNumString.IndexOf("千");
if (index != -1)
{
result +=this.switchNum(ChnNumString.Substring(0, index)) * 1000;
ChnNumString =ChnNumString.Remove(0, index + 1);
}
index = ChnNumString.IndexOf("百");
if (index != -1)
{
result +=this.switchNum(ChnNumString.Substring(0 , index)) * 100;
ChnNumString = ChnNumString.Remove(0, index + 1);
}
index = ChnNumString.IndexOf("十");
if (index != -1)
{
result += this.switchNum(ChnNumString.Substring(0 , index)) * 10;
ChnNumString = ChnNumString.Remove(0, index + 1);
}
if (ChnNumString != string.Empty)
{
result += this.switchNum(ChnNumString);
}
return result;
}
/// <summary>
    /// 取得汉字对应的阿拉伯数字
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
private int switchNum(string n)
{
switch (n)
{
case "零":
{
return 0;
}
case "一":
{
return 1;
}
case "二":
{
return 2;
}
case "三":
{
return 3;
}
case "四":
{
return 4;
}
case "五":
{
return 5;
}
case "六":
{
return 6;
}
case "七":
{
return 7;
}
case "八":
{
return 8;
}
case "九":
{
return 9;
}
default:
{
return -1;
}
}
}
}
}

 

 

//类名:myGSMModem
//作用:短信猫类
//作者:刘典武修正(通用于深圳百亿科技GSM)
//时间:2011-03-01
//说明:来源于博客园(修正)

///页面调用的方法

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.IO.Ports;

NumberConventer NC = new NumberConventer();//新建工作类对象
string TP = string.Empty;//TP转换结果
this.txtTotalPriceUP.Text = NC.ArabToChn(Convert.ToDecimal(_TotalPrice), out TP);//这个方法返回结果,类型string,能处理的数字大小为一亿个亿

namespace myClassLibrary
{
    public enum MsgType { AUSC2, A7Bit };//枚举 短信类型 AUSC2 A7Bit:7位编码 (中文用AUSC2,英文都可以 但7Bit能发送160字符,USC2仅70)
    public class myGSM
    {
        #region  构造函数
        /// <summary>
        /// 无参数构造函数 完成有关初始化工作
        /// </summary>
        public myGSM()
        {
            this.msgCenter = string.Empty;
            this.sp = new SerialPort();
            this.sp.ReadTimeout = -1;//读超时时间 发送短信时间的需要
            this.sp.RtsEnable = true;//必须为true 这样串口才能接收到数据
            this.sp.DataReceived += new SerialDataReceivedEventHandler(this.sp_DataReceived);
        }

 

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="comPort">串口号</param>
        /// <param name="baudRate">波特率</param>
        public myGSM(string comPort, int baudRate)
        {
            this.msgCenter = string.Empty;
            this.sp = new SerialPort();
            this.sp.PortName = comPort;
            this.sp.BaudRate = baudRate;
            this.sp.ReadTimeout = -1;//读超时时间 发送短信时间的需要
            this.sp.RtsEnable = true;//必须为true 这样串口才能接收到数据
            this.sp.DataReceived += new SerialDataReceivedEventHandler(this.sp_DataReceived);
        }
        #endregion

        #region  私有变量
        private SerialPort sp;
        private bool autoDelMsg = false;//是否自动删除短消息
        private string msgCenter = string.Empty;//服务中心号码
        private int newMsgIndex;//新消息序号
        #endregion

        #region 属性
        /// <summary>
        /// 是否自动删除短信(默认为false)
        /// </summary>
        public bool AutoDelMsg
        {
            get { return this.autoDelMsg; }
            set { this.autoDelMsg = value; }
        }

        /// <summary>
        /// 波特率 运行时只读 设备打开状态写入将引发异常
        /// </summary>
        public int BaudRate
        {
            get { return this.sp.BaudRate; }
            set { this.sp.BaudRate = value; }
        }

        /// <summary>
        /// 串口号 运行时只读 设备打开状态写入将引发异常
        /// 提供对串口端口号的访问
        /// </summary>
        public string ComPort
        {
            get { return this.sp.PortName; }
            set { try { this.sp.PortName = value; } catch (Exception ex) { throw ex; } }
        }

        /// <summary>
        /// 设备是否打开
        /// </summary>
        public bool IsOpen
        {
            get { return this.sp.IsOpen; }
        }

        #endregion

        #region  方法

        /// <summary>
        /// 设置服务中心号码
        /// </summary>
        /// <param name="msgCenterNo"></param>
        public void SetMsgCenterNo(string msgCenterNo)
        {
            this.msgCenter = msgCenterNo;
        }

        /// <summary>
        /// 获取机器码
        /// </summary>
        /// <returns></returns>
        public string GetMachineNo()
        {
            string temp = this.SendAT("AT+CGMI");
            if (temp.Substring(temp.Length - 4, 3).Trim() == "OK")
            {
                temp = temp.Split('r')[2].Trim();
            }
            else
            {
                throw new Exception("获取机器码失败");
            }
            return temp;
        }

        /// <summary>
        /// 获取短信中心号码
        /// </summary>
        /// <returns></returns>
        public string GetMsgCenterNo()
        {
            string temp = string.Empty;
            if (msgCenter != null && msgCenter.Length != 0)
            {
                return msgCenter;
            }
            else
            {
                temp = this.SendAT("AT+CSCA?");
                if (temp.Substring(temp.Length - 4, 3).Trim() == "OK")
                {
                    return temp.Split('"')[1].Trim();
                }
                else
                {
                    throw new Exception("获取短信中心失败");
                }
            }
        }

        /// <summary>
        /// 取得未读信息列表
        /// </summary>
        /// <returns>未读信息列表(中心号码,手机号码,发送时间,短信内容)</returns>
        public string[] GetUnReadMsg()
        {
            string[] result = new string[255];//存储255条短信,一般手机上面存储的短信少于这个数
            string[] temp = null;
            string tt = string.Empty;

            tt = this.SendAT("AT+CMGL=0");//读取未读信息
            if (tt.Substring(tt.Length - 4, 3).Trim() == "OK")
            {
                temp = tt.Split('r');
            }
            PDUEncoding pe = new PDUEncoding();
            int i = 0;//计数
            foreach (string str in temp)
            {
                if (str != null && str.Length != 0 && str.Substring(0, 2).Trim() != "+C" && str.Substring(0, 2) != "OK" && str.Substring(0, 2) != "AT")
                {
                    result[i] = pe.PDUDecoder(str);
                    i++;
                }
            }
            return result;
        }

        /// <summary>
        /// 取得已读信息列表
        /// </summary>
        /// <returns>已读信息列表(中心号码,手机号码,发送时间,短信内容)</returns>
        public string[] GetIsReadMsg()
        {
            string[] result = new string[255];//存储255条短信,一般手机上面存储的短信少于这个数
            string[] temp = null;
            string tt = string.Empty;

            tt = this.SendAT("AT+CMGL=1");//读取已读信息
            if (tt.Substring(tt.Length - 4, 3).Trim() == "OK")
            {
                temp = tt.Split('r');
            }
            PDUEncoding pe = new PDUEncoding();
            int i = 0;//计数
            foreach (string str in temp)
            {
                if (str != null && str.Length != 0 && str.Substring(0, 2).Trim() != "+C" && str.Substring(0, 2) != "OK" && str.Substring(0, 2) != "AT")
                {
                    result[i] = pe.PDUDecoder(str);
                    i++;
                }
            }
            return result;
        }

        /// <summary>
        /// 取得待发信息列表
        /// </summary>
        /// <returns>待发信息列表(中心号码,手机号码,发送时间,短信内容)</returns>
        public string[] GetUnSendMsg()
        {
            string[] result = new string[255];//存储255条短信,一般手机上面存储的短信少于这个数
            string[] temp = null;
            string tt = string.Empty;

            tt = this.SendAT("AT+CMGL=2");//读取待发信息
            if (tt.Substring(tt.Length - 4, 3).Trim() == "OK")
            {
                temp = tt.Split('r');
            }
            PDUEncoding pe = new PDUEncoding();
            int i = 0;//计数
            foreach (string str in temp)
            {
                if (str != null && str.Length != 0 && str.Substring(0, 2).Trim() != "+C" && str.Substring(0, 2) != "OK" && str.Substring(0, 2) != "AT")
                {
                    result[i] = pe.PDUDecoder(str);
                    i++;
                }
            }
            return result;
        }

        /// <summary>
        /// 取得已发信息列表
        /// </summary>
        /// <returns>已发信息列表(中心号码,手机号码,发送时间,短信内容)</returns>
        public string[] GetIsSendMsg()
        {
            string[] result = new string[255];//存储255条短信,一般手机上面存储的短信少于这个数
            string[] temp = null;
            string tt = string.Empty;

            tt = this.SendAT("AT+CMGL=3");//读取已发信息
            if (tt.Substring(tt.Length - 4, 3).Trim() == "OK")
            {
                temp = tt.Split('r');
            }
            PDUEncoding pe = new PDUEncoding();
            int i = 0;//计数
            foreach (string str in temp)
            {
                if (str != null && str.Length != 0 && str.Substring(0, 2).Trim() != "+C" && str.Substring(0, 2) != "OK" && str.Substring(0, 2) != "AT")
                {
                    result[i] = pe.PDUDecoder(str);
                    i++;
                }
            }
            return result;
        }

        /// <summary>
        /// 获取所有信息
        /// </summary>
        /// <returns></returns>
        public string[] GetAllMsg()
        {
            string[] result = new string[255];//存储255条短信,一般手机上面存储的短信少于这个数
            string[] temp = null;
            string tt = string.Empty;

            tt = this.SendAT("AT+CMGL=4");//读取未读信息
            if (tt.Substring(tt.Length - 4, 3).Trim() == "OK")
            {
                temp = tt.Split('r');
            }
            PDUEncoding pe = new PDUEncoding();
            int i = 0;//计数
            foreach (string str in temp)
            {
                if (str != null && str.Length != 0 && str.Substring(0, 2).Trim() != "+C" && str.Substring(0, 2) != "OK" && str.Substring(0, 2) != "AT")
                {
                    result[i] = pe.PDUDecoder(str);
                    i++;
                }
            }
            return result;
        }

        /// <summary>
        /// 读取设备新收到的短消息
        /// </summary>
        /// <returns></returns>
        public string ReadNewMsg()
        {
            return ReadMsgByIndex(newMsgIndex);
        }

        /// <summary>
        /// 发送AT命令
        /// </summary>
        /// <param name="ATCom">AT命令</param>
        /// <returns></returns>
        public string SendAT(string ATCom)
        {
            string str = string.Empty;
            //忽略接收缓冲区内容,准备发送
            this.sp.DiscardInBuffer();
            //注销事件关联,为发送做准备
            this.sp.DataReceived -= this.sp_DataReceived;
            try
            {
                this.sp.Write(ATCom + "r");
            }
            catch (Exception ex)
            {
                this.sp.DataReceived += this.sp_DataReceived;
                throw ex;
            }
            try
            {
                string temp = string.Empty;
                while ((temp.Trim() != "OK") && (temp.Trim() != "ERROR"))
                {
                    temp = this.sp.ReadLine();
                    str += temp;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                this.sp.DataReceived += this.sp_DataReceived;
            }
            return str;
        }

        /// <summary>
        /// 发送短信       
        /// </summary>
        /// <param name="phone">手机号码</param>
        /// <param name="msg">短信内容</param>
        public bool SendMsg(string phone, string msg)
        {
            string temp = "0011000D91" + this.reverserNumber(phone) + "000801" + this.contentEncoding(msg) + Convert.ToChar(26).ToString();
            string len = this.getLenght(msg);//计算长度

            try
            {
                this.sp.DataReceived -= sp_DataReceived;
                this.sp.Write("AT+CMGS=" + len + "r");
                this.sp.ReadTo(">");
                this.sp.DiscardInBuffer();
                //事件重新绑定 正常监视串口数据
                this.sp.DataReceived += sp_DataReceived;
                temp = this.SendAT(temp);
                if (temp.Substring(temp.Length - 4, 3).Trim() != "OK")
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            catch { return false; }
        }

        #region  自定义方法

        //获取短信内容的字节数
        private string getLenght(string txt)
        {
            int i = 0;
            string s = "";
            i = txt.Length * 2;
            i += 15;
            s = i.ToString();
            return s;
        }
        //将手机号码转换为内存编码
        private string reverserNumber(string phone)
        {
            string str = "";
            //检查手机号码是否按照标准格式写,如果不是则补上
            if (phone.Substring(0, 2) != "86")
            {
                phone = string.Format("86{0}", phone);
            }
            char[] c = this.getChar(phone);
            for (int i = 0; i <= c.Length - 2; i += 2)
            {
                str += c[i + 1].ToString() + c[i].ToString();
            }
            return str;
        }
        //汉字解码为16进制
        private string contentEncoding(string content)
        {
            Encoding encodingUTF = System.Text.Encoding.BigEndianUnicode;
            string s = "";
            byte[] encodeByte = encodingUTF.GetBytes(content);
            for (int i = 0; i <= encodeByte.Length - 1; i++)
            {
                s += BitConverter.ToString(encodeByte, i, 1);
            }
            s = string.Format("{0:X2}{1}", s.Length / 2, s);
            return s;
        }

        private char[] getChar(string phone)
        {
            if (phone.Length % 2 == 0)
            {
                return Convert.ToString(phone).ToCharArray();
            }
            else
            {
                return Convert.ToString(phone + "F").ToCharArray();
            }
        }
        #endregion

        /// <summary>
        /// 发送短信 (重载)
        /// </summary>
        /// <param name="phone">手机号码</param>
        /// <param name="msg">短信内容</param>
        /// <param name="msgType">短信类型</param>
        public void SendMsg(string phone, string msg, MsgType msgType)
        {
            if (msgType == MsgType.AUSC2)
            {
                SendMsg(phone, msg);
            }
            else
            {

                PDUEncoding pe = new PDUEncoding();
                pe.ServiceCenterAddress = msgCenter;                    //短信中心号码 服务中心地址

                string temp = pe.PDU7BitEncoder(phone, msg);

                int len = (temp.Length - Convert.ToInt32(temp.Substring(0, 2), 16) * 2 - 2) / 2;  //计算长度
                try
                {
                    temp = SendAT("AT+CMGS=" + len.ToString() + "r" + temp + (char)(26));  //26 Ctrl+Z ascii码
                }
                catch (Exception)
                {
                    throw new Exception("短信发送失败");
                }

                if (temp.Substring(temp.Length - 4, 3).Trim() == "OK")
                {
                    return;
                }

                throw new Exception("短信发送失败");
            }
        }

        /// <summary>
        /// 关闭设备
        /// </summary>
        public void CloseComm()
        {
            try
            {
                this.sp.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 打开设备
        /// </summary>
        public void OpenComm()
        {
            try
            {
                this.sp.Open();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            if (this.sp.IsOpen)
            {
                //this.sp.DataReceived -= this.sp_DataReceived;
                //this.sp.Write("ATr");
                //Thread.Sleep(100);
                //string s = this.sp.ReadExisting().Trim();
                //s = s.Substring(s.Length - 2, 2);
                //if (s != "OK")
                //{
                //    throw new Exception("硬件连接错误");
                //}

                try
                {
                    this.SendAT("AT+CMGF=0");//选择短消息格式默认为PDU
                    Thread.Sleep(100);
                    this.SendAT("AT+CNMI=2,1");//选择当有新短消息来时提示方式
                    Thread.Sleep(100);
                }
                catch { }
            }
        }

        /// <summary>
        /// 拨打电话
        /// </summary>
        /// <param name="telNum">电话号码</param>
        public void Call(string telNum)
        {
            try
            {
                this.SendAT("ATD" + telNum + ";");
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 按序号读取短信
        /// </summary>
        /// <param name="index">序号</param>
        /// <param name="msgCenter">短信中心</param>
        /// <param name="phone">发送方手机号码</param>
        /// <param name="msg">短信内容</param>
        /// <param name="time">时间字符串</param>
        public void ReadMsgByIndex(int index, out string msgCenter, out string phone, out string msg, out string time)
        {
            string temp = string.Empty;
            PDUEncoding pe = new PDUEncoding();
            try
            {
                temp = SendAT("AT+CMGR=" + index.ToString() + "r");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            if (temp.Trim() == "ERROR")
            {
                throw new Exception("没有此短信");
            }
            temp = temp.Split((char)(13))[2];       //取出PDU串(char)(13)为0x0a即r 按r分为多个字符串 第3个是PDU串

            pe.PDUDecoder(temp, out msgCenter, out phone, out msg, out time);
        }

        /// <summary>
        /// 按序号读取短信
        /// </summary>
        /// <param name="index">序号</param>
        /// <returns>信息字符串 (中心号码,手机号码,发送时间,短信内容)</returns>
        public string ReadMsgByIndex(int index)
        {
            string temp = string.Empty;
            string msgCenter, phone, msg, time;
            PDUEncoding pe = new PDUEncoding();
            try
            {
                temp = SendAT("AT+CMGR=" + index.ToString());
            }
            catch (Exception ex)
            {
                throw ex;
            }

            if (temp.Trim() == "ERROR")
            {
                throw new Exception("没有此短信");
            }

            temp = temp.Split((char)(13))[3];       //取出PDU串(char)(13)为0x0a即r 按r分为多个字符串 第3个是PDU串

            pe.PDUDecoder(temp, out msgCenter, out phone, out msg, out time);

            if (AutoDelMsg)//如果阅读完短信自动删除设置为真
            {
                try
                {
                    DelMsgByIndex(index);
                }
                catch { }
            }
            return msgCenter + "," + phone + "," + time + "," + msg;
        }

        /// <summary>
        /// 删除对应序号短信
        /// </summary>
        /// <param name="index">短信序号</param>
        /// <returns></returns>
        public bool DelMsgByIndex(int index)
        {
            if (SendAT("AT+CMGD=" + index.ToString()).Trim() == "OK")
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        #endregion

        /// <summary>
        /// 创建事件收到信息的委托
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void OnRecievedHandler(object sender, EventArgs e);

        /// <summary>
        /// 收到短信息事件 OnRecieved
        /// 收到短信将引发此事件
        /// </summary>
        public event OnRecievedHandler GetNewMsg;

        private void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            string str = this.sp.ReadLine();
            if ((str.Length > 8) && (str.Substring(0, 6) == "+CMTI:"))
            {
                this.newMsgIndex = Convert.ToInt32(str.Split(',')[1]);
                this.GetNewMsg(this, e);
            }
        }
    }

    class PDUEncoding
    {
        private string serviceCenterAddress = "00";
        /// <summary>
        /// 消息服务中心(1-12个8位组)
        /// </summary>
        public string ServiceCenterAddress
        {
            get
            {
                int len = 2 * Convert.ToInt32(serviceCenterAddress.Substring(0, 2));
                string result = serviceCenterAddress.Substring(4, len - 2);

                result = ParityChange(result);
                result = result.TrimEnd('F', 'f');
                return result;
            }
            set                 //
            {
                if (value == null || value.Length == 0)      //号码为空
                {
                    serviceCenterAddress = "00";
                }
                else
                {
                    if (value[0] == '+')
                    {
                        value = value.TrimStart('+');
                    }
                    if (value.Substring(0, 2) != "86")
                    {
                        value = "86" + value;
                    }
                    value = "91" + ParityChange(value);
                    serviceCenterAddress = (value.Length / 2).ToString("X2") + value;
                }

            }
        }

        private string protocolDataUnitType = "11";
        /// <summary>
        /// 协议数据单元类型(1个8位组)
        /// </summary>
        public string ProtocolDataUnitType
        {
            set
            {

            }
            get
            {
                return "11";
            }
        }

        private string messageReference = "00";
        /// <summary>
        /// 所有成功的短信发送参考数目(0..255)
        /// (1个8位组)
        /// </summary>
        public string MessageReference
        {
            get
            {
                return "00";
            }
        }

        private string originatorAddress = "00";
        /// <summary>
        /// 发送方地址(手机号码)(2-12个8位组)
        /// </summary>
        public string OriginatorAddress
        {
            get
            {
                int len = Convert.ToInt32(originatorAddress.Substring(0, 2), 16);    //十六进制字符串转为整形数据
                string result = string.Empty;
                if (len % 2 == 1)       //号码长度是奇数,长度加1 编码时加了F
                {
                    len++;
                }
                result = originatorAddress.Substring(4, len);
                result = ParityChange(result).TrimEnd('F', 'f');    //奇偶互换,并去掉结尾F

                return result;
            }
        }

        private string destinationAddress = "00";
        /// <summary>
        /// 接收方地址(手机号码)(2-12个8位组)
        /// </summary>
        public string DestinationAddress
        {
            set
            {
                if (value == null || value.Length == 0)      //号码为空
                {
                    destinationAddress = "00";
                }
                else
                {
                    if (value[0] == '+')
                    {
                        value = value.TrimStart('+');
                    }
                    if (value.Substring(0, 2) == "86")
                    {
                        value = value.TrimStart('8', '6');
                    }
                    int len = value.Length;
                    value = ParityChange(value);

                    destinationAddress = len.ToString("X2") + "A1" + value;
                }
            }
        }

        private string protocolIdentifer = "00";
        /// <summary>
        /// 参数显示消息中心以何种方式处理消息内容
        /// (比如FAX,Voice)(1个8位组)
        /// </summary>
        public string ProtocolIdentifer
        {
            get
            {
                return protocolIdentifer;
            }
            set
            {

            }
        }

        private string dataCodingScheme = "08";     //暂时仅支持国内USC2编码
        /// <summary>
        /// 参数显示用户数据编码方案(1个8位组)
        /// </summary>
        public string DataCodingScheme
        {
            get
            {
                return dataCodingScheme;
            }
        }

        private string serviceCenterTimeStamp = "";
        /// <summary>
        /// 消息中心收到消息时的时间戳(7个8位组)
        /// </summary>
        public string ServiceCenterTimeStamp
        {
            get
            {
                string result = ParityChange(serviceCenterTimeStamp);
                result = "20" + result.Substring(0, 12);            //年加开始的“20”

                return result;
            }
        }

        private string validityPeriod = "C4";       //暂时固定有效期
        /// <summary>
        /// 短消息有效期(0,1,7个8位组)
        /// </summary>
        public string ValidityPeriod
        {
            get
            {
                return "C4";
            }
        }

        private string userDataLenghth = "";
        /// <summary>
        /// 用户数据长度(1个8位组)
        /// </summary>
        public string UserDataLenghth
        {
            get
            {
                return (userData.Length / 2).ToString("X2");
            }
        }

        private string userData = "";
        /// <summary>
        /// 用户数据(0-140个8位组)
        /// </summary>
        public string UserData
        {
            get
            {
                int len = Convert.ToInt32(userDataLenghth, 16) * 2;
                string result = string.Empty;

                if (dataCodingScheme == "08" || dataCodingScheme == "18")             //USC2编码
                {
                    //四个一组,每组译为一个USC2字符
                    for (int i = 0; i < len; i += 4)
                    {
                        string temp = userData.Substring(i, 4);

                        int byte1 = Convert.ToInt16(temp, 16);

                        result += ((char)byte1).ToString();
                    }
                }
                else
                {
                    result = PDU7bitDecoder(userData);
                }

                return result;
            }
            set
            {
                userData = string.Empty;
                Encoding encodingUTF = Encoding.BigEndianUnicode;

                byte[] Bytes = encodingUTF.GetBytes(value);

                for (int i = 0; i < Bytes.Length; i++)
                {
                    userData += BitConverter.ToString(Bytes, i, 1);
                }
                userDataLenghth = (userData.Length / 2).ToString("X2");
            }
        }

        /// <summary>
        /// 奇偶互换 (+F)
        /// </summary>
        /// <param name="str">要被转换的字符串</param>
        /// <returns>转换后的结果字符串</returns>
        private string ParityChange(string str)
        {
            string result = string.Empty;

            if (str.Length % 2 != 0)         //奇字符串 补F
            {
                str += "F";
            }
            for (int i = 0; i < str.Length; i += 2)
            {
                result += str[i + 1];
                result += str[i];
            }

            return result;
        }

        /// <summary>
        /// PDU编码器,完成PDU编码(USC2编码,最多70个字)
        /// </summary>
        /// <param name="phone">目的手机号码</param>
        /// <param name="Text">短信内容</param>
        /// <returns>编码后的PDU字符串</returns>
        public string PDUEncoder(string phone, string Text)
        {
            if (Text.Length > 70)
            {
                throw (new Exception("短信字数超过70"));
            }
            DestinationAddress = phone;
            UserData = Text;

            return serviceCenterAddress + protocolDataUnitType
                + messageReference + destinationAddress + protocolIdentifer
                + dataCodingScheme + validityPeriod + userDataLenghth + userData;
        }

        /// <summary>
        /// 7bit 编码
        /// </summary>
        /// <param name="phone">手机号码</param>
        /// <param name="Text">短信内容</param>
        /// <returns>编码后的字符串</returns>
        public string PDU7BitEncoder(string phone, string Text)
        {
            if (Text.Length > 160)
            {
                throw new Exception("短信字数大于160");
            }
            dataCodingScheme = "00";
            DestinationAddress = phone;
            UserData = Text;

            return serviceCenterAddress + protocolDataUnitType
                + messageReference + destinationAddress + protocolIdentifer
                + dataCodingScheme + validityPeriod + userDataLenghth + userData;
        }

        /// <summary>
        /// 重载 解码,返回信息字符串
        /// </summary>
        /// <param name="strPDU">短信PDU字符串</param>
        /// <returns>信息字符串(中心号码,手机号码,发送时间,短信内容)</returns>
        public string PDUDecoder(string strPDU)
        {
            int length = (Convert.ToInt32(strPDU.Substring(0, 2), 0x10) * 2) + 2;
            this.serviceCenterAddress = strPDU.Substring(0, length);
            int num2 = Convert.ToInt32(strPDU.Substring(length + 2, 2), 0x10);
            if ((num2 % 2) == 1)
            {
                num2++;
            }
            num2 += 4;
            this.originatorAddress = strPDU.Substring(length + 2, num2);
            this.dataCodingScheme = strPDU.Substring((length + num2) + 4, 2);
            this.serviceCenterTimeStamp = strPDU.Substring((length + num2) + 6, 14);
            this.userDataLenghth = strPDU.Substring((length + num2) + 20, 2);
            Convert.ToInt32(this.userDataLenghth, 0x10);
            this.userData = strPDU.Substring((length + num2) + 0x16);
            return (this.ServiceCenterAddress + "," + this.OriginatorAddress + "," + this.ServiceCenterTimeStamp + "," + this.UserData);
        }

        /// <summary>
        /// 完成手机或短信猫收到PDU格式短信的解码 暂时仅支持中文编码
        /// 未用DCS部分
        /// </summary>
        /// <param name="strPDU">短信PDU字符串</param>
        /// <param name="msgCenter">短消息服务中心 输出</param>
        /// <param name="phone">发送方手机号码 输出</param>
        /// <param name="msg">短信内容 输出</param>
        /// <param name="time">时间字符串 输出</param>
        public void PDUDecoder(string strPDU, out string msgCenter, out string phone, out string msg, out string time)
        {
            int lenSCA = Convert.ToInt32(strPDU.Substring(0, 2), 16) * 2 + 2;       //短消息中心占长度
            serviceCenterAddress = strPDU.Substring(0, lenSCA);

            int lenOA = Convert.ToInt32(strPDU.Substring(lenSCA + 2, 2), 16);           //OA占用长度
            if (lenOA % 2 == 1)                                                     //奇数则加1 F位
            {
                lenOA++;
            }
            lenOA += 4;                 //加号码编码的头部长度
            originatorAddress = strPDU.Substring(lenSCA + 2, lenOA);

            dataCodingScheme = strPDU.Substring(lenSCA + lenOA + 4, 2);             //DCS赋值,区分解码7bit

            serviceCenterTimeStamp = strPDU.Substring(lenSCA + lenOA + 6, 14);

            userDataLenghth = strPDU.Substring(lenSCA + lenOA + 20, 2);
            int lenUD = Convert.ToInt32(userDataLenghth, 16) * 2;
            userData = strPDU.Substring(lenSCA + lenOA + 22);

            msgCenter = ServiceCenterAddress;
            phone = OriginatorAddress;
            msg = UserData;
            time = ServiceCenterTimeStamp;
        }

        /// <summary>
        /// PDU7bit的解码,供UserData的get访问器调用
        /// </summary>
        /// <param name="len">用户数据长度</param>
        /// <param name="userData">数据部分PDU字符串</param>
        /// <returns></returns>
        private string PDU7bitDecoder(string userData)
        {
            string result = string.Empty;
            byte[] b = new byte[100];
            string temp = string.Empty;

            for (int i = 0; i < userData.Length; i += 2)
            {
                b[i / 2] = (byte)Convert.ToByte((userData[i].ToString() + userData[i + 1].ToString()), 16);
            }

            int j = 0;            //while计数
            int tmp = 1;            //temp中二进制字符字符个数
            while (j < userData.Length / 2 - 1)
            {
                string s = string.Empty;

                s = Convert.ToString(b[j], 2);

                while (s.Length < 8)            //s补满8位 byte转化来的 有的不足8位,直接解码将导致错误
                {
                    s = "0" + s;
                }

                result += (char)Convert.ToInt32(s.Substring(tmp) + temp, 2);        //加入一个字符 结果集 temp 上一位组剩余

                temp = s.Substring(0, tmp);             //前一位组多的部分

                if (tmp > 6)                            //多余的部分满7位,加入一个字符
                {
                    result += (char)Convert.ToInt32(temp, 2);
                    temp = string.Empty;
                    tmp = 0;
                }

                tmp++;
                j++;

                if (j == userData.Length / 2 - 1)           //最后一个字符
                {
                    result += (char)Convert.ToInt32(Convert.ToString(b[j], 2) + temp, 2);
                }
            }
            return result;
        }
    }
}

 

 

 

 

 

 

 

本文由9159.com发布于编程,转载请注明出处:激发学习C,所以暂时不标明出处

关键词:

上一篇:没有了
下一篇:没有了