unitmodem.pas

串口短信猫收发软件。支持西门子TC35i设备

{*******************************************************}
{                                                       }
{  名称：TModem类                                       }
{  功能：                                               }
{      1.继承TSerial类                                  }
{      2.定义不同设备间短信收发接口                     }
{  调用：                                               }
{      1.TModem子类实例化抽象方法                       }
{      2.TModemPool类创建TModem子类实例                 }
{      3.TModemPool类调用TModem类的虚方法               }
{                                                       }
{*******************************************************}

{*************************************************************************}
{  AT 指令认证                                                            }
{  ATI 认证信息                                                           }
{  AT+CGMI 厂家认证                                                       }
{  AT+CGMM 模块认证                                                       }
{  AT+CGMR 版本认证                                                       }
{  AT&V 显示设置                                                          }
{  AT+CSQ 网络信号                                                        }
{  AT+CGSN 查询设备序列号(IMEI)                                           }
{  AT+CIMI 查询SIM卡序列号(IMSI国际移动签署者标识)                        }
{  AT+COPS? 查询当前网络                                                  }
{  AT+CMGC Send an SMS command（发出一条短消息命令）                      }
{  AT+CMGD Delete SMS message（删除SIM卡内存的短消息）                    }
{  AT+CMGF Select SMS message formate（选择短消息信息格式：0-PDU;1-文本） }
{  AT+CMGL List SMS message from preferred store			  }
{  （列出SIM卡中的短消息PDU/text: 0/"REC UNREAD"-未读，1/"REC READ"-已读  }
{    2/"STO UNSENT"-待发，3/"STO SENT"-已发，4/"ALL"-全部的               }
{  AT+CMGR Read SMS message（读短消息）                                   }
{  AT+CMGS Send SMS message（发送短消息）                                 }
{  AT+CMGW Write SMS message to memory（向SIM内存中写入待发的短消息）     }
{  AT+CMSS Send SMS message from storage（从SIN|M内存中发送短消息）       }
{  AT+CNMI New SMS message indications（显示新收到的短消息）              }
{  AT+CPMS Preferred SMS message storage（选择短消息内存）                }
{  AT+CSCA SMS service center address（短消息中心地址）                   }
{  AT+CSCB Select cell broadcast messages（选择蜂窝广播消息）             }
{  AT+CSMP Set SMS text mode parameters（设置短消息文本模式参数）         }
{  AT+CSMS Select Message Service（选择短消息服务）                       }
{*************************************************************************}

unit UnitModem;

interface

uses
  Windows, Messages, SysUtils, Forms, Classes, Dialogs, SyncObjs, UnitPublicFun, UnitSerial;

type
  TModem = class(TSerial)
  private
    FNetDefine: integer;                                                        //网络标识:0-中国联通,1-中国移动
  protected
    FSMSCenter: string;                                                         //短信中心号码
    function IntToHexStr(i: integer): string;                                   //十进制整数转换成十六进制
    function HexStrToInt(s: string): integer;                                   //十六进制字符串转换成十进制数
    function HexCharToInt(HexToken: char): integer;
    function HexCharToBin(HexToken: char): string;
    function HexToBin(HexNr: string): string;
    function pow(base, power: integer): integer;
    function BinStrToInt(BinStr: string): integer;
    function ExchangeCode(s: string): string;                                   //字符PDU转换
    function gsmEncodeUcs2(ws: widestring): string;                             //按Ucs2格式编码
    function gsmDecodeUcs2(s: string): string;                                  //按Ucs2格式解码
    function gsmEncode7bit(s: string): string;                                  //按7bit格式编码
    function gsmDecode7bit(s: string): string;                                  //按7bit格式解码
  public
    function ATCommandTest: boolean; virtual;                                   //可被override的虚方法：AT指令测试
    function GetModemStatus: string; virtual;                                   //可被override的虚方法：获取MODEM状态
  published
    property ModemOpen: boolean read ATCommandTest;
    property NetDefine: integer read FNetDefine write FNetDefine;
  public
    function GetModemInfo: string; virtual; abstract;                           //抽象方法：获取MODEM信息
    function GetNetSignal: string; virtual; abstract;                           //抽象方法：获取信号强度
    function GetSIMID: string; virtual; abstract;                               //抽象方法：获取SIM卡序列号
    function GetSIMServerNo: string; virtual; abstract;                         //抽象方法：获取短信中心服务号码
    function SetZero: boolean; virtual; abstract;                               //抽象方法：恢复到厂商默认设置
    function SetSIMServerNo(strSIMServerNo: string): boolean; virtual; abstract;//抽象方法：设置短信中心服务号码
    function SetPduMode: boolean; virtual; abstract;                            //抽象方法：设置成PDU模式
    function SetTECharacterSet: boolean; virtual; abstract;                     //抽象方法：设置字符集
    function SetReportErrorOff: boolean; virtual; abstract;                     //抽象方法：设置错误码回显关闭
    function SetEchoOff: boolean; virtual; abstract;                            //抽象方法：设置回显关闭
    function SendPduSMS(data: string;
                        mobile: string): boolean; virtual; abstract;            //抽象方法：发送PDU格式短信
    function RecievePduSMS(bAutoDel: boolean;
                           var MsgNum: integer;
                           var MsgArray: array of TRecieveSMS): boolean; virtual; abstract;      //抽象方法：接收PDU格式短信
  end;

implementation

{ TModem }

function TModem.HexCharToInt(HexToken: char): integer;
begin
  {if HexToken>#97 then HexToken:=Chr(Ord(HexToken)-32);
  { use lowercase aswell }

  Result := 0;
  if (HexToken>#47) and (HexToken<#58) then                                     { chars 0....9 }
     Result := Ord(HexToken) - 48
  else if (HexToken>#64) and (HexToken<#71) then                                { chars A....F }
     Result := Ord(HexToken) - 65 + 10;
end;

function TModem.HexCharToBin(HexToken: char): string;
var
  DivLeft: integer;
begin
  DivLeft := HexCharToInt(HexToken);                                            { first HEX->BIN }
  Result := '';
                                                                                { Use reverse dividing }
  repeat                                                                        { Trick; divide by 2 }
    if odd(DivLeft) then                                                        { result = odd ? then bit = 1 }
      Result := '1' + Result                                                    { result = even ? then bit = 0 }
    else
      Result := '0' + Result;
    DivLeft := DivLeft div 2;                                                   { keep dividing till 0 left and length = 4 }
  until (DivLeft=0) and (length(Result)=4);                                     { 1 token = nibble = 4 bits }
end;

function TModem.HexToBin(HexNr: string): string;                                { only stringsize is limit of binnr }
var
  Counter: integer;
begin
  Result := '';

  for Counter := 1 to length(HexNr) do
    Result := Result + HexCharToBin(HexNr[Counter]);
end;

function TModem.pow(base, power: integer): integer;
var
  counter: integer;
begin
  Result := 1;

  for counter:=1 to power do
    Result := Result * base;
end;

function TModem.BinStrToInt(BinStr: string): integer;
var
  counter: integer;
begin
  if length(BinStr)>16 then
    raise ERangeError.Create(#13+BinStr+#13+
            'is not within the valid range of a 16 bit binary.'+#13);
  Result := 0;

  for counter:=1 to length(BinStr) do
    if BinStr[Counter]='1' then
      Result := Result + pow(2, length(BinStr)-counter);
end;

function TModem.HexStrToInt(s: string): integer;
var
  H, L: integer;
begin
  H := Ord(s[1]);
  if H >= 65 then H := H-55 else H := H-48;
  L := Ord(s[2]);
  if L >= 65 then L := L-55 else L := L-48;
  Result := H * 16 + L;
end;

function TModem.IntToHexStr(i: integer): string;
var
  H,L: integer;
begin
  H := i div 16;
  if H < 10 then H:=H+48 else H:=H+55;
  L := i mod 16;
  if L < 10 then L:=L+48 else L:=L+55;
  Result := Chr(H) + Chr(L);
end;

function TModem.ExchangeCode(s: string): string;
var
  i, iLen: integer;
  strSrc, strResult: string;
begin
  strResult := '';
  iLen := Length(s);
  strSrc := s;
  
  //如果长度不为偶数则后补F
  if iLen mod 2 <> 0 then
    strSrc := s + 'F';
    
  i := 1;
  while i<=iLen do
  begin
    strResult := strResult + strSrc[i+1] + strSrc[i];
    Inc(i, 2);
  end;
  Result := strResult;
end;

function TModem.gsmEncodeUcs2(ws: widestring): string;
var
  i, len : integer;
  cur : integer;
  t : string;
begin
  Result := '';
  len := Length(ws);
  i := 1;
  while i<=len do
  begin
    cur := Ord(ws[i]);
    FmtStr(t, '%4.4X', [cur]);
    Result := Result + t;
    Inc(i);
  end;
end;

function TModem.gsmDecodeUcs2(s: string): string;
var
  i, iLen: integer;
  Buf: array[0..1000] of WideChar;
begin
  iLen := Round(Length(s) / 4) - 1;
  for i:=0 to iLen do
  begin
    Buf[i] := widechar(StrToint('$' + copy(s, 4*i+1, 4)));
  end;
  Buf[iLen+1] := #0;
  Result := WideCharToString(Buf);
end;

function TModem.gsmEncode7bit(s: string): string;
var
  i, j, len: Integer;
  cur: Integer;
  t: string;
begin
  Result := '';
  len := Length(s);

  i := 1;
  j := 0;                                                                       //j 用于移位计数
  while i<=len do
  begin
    if i<len then
      cur := (ord(s[i]) shr j) or ((ord(s[i+1]) shl (7-j)) and $ff)             //数据变换
    else
      cur := (ord(s[i]) shr j) and $7f;

    FmtStr(t,'%2.2X',[cur]);

    Result := Result + t;

    Inc(i);

    j := (j+1) mod 7;                                                           //移位计数达到7位的特别处理
    if j=0 then Inc(i);
  end;
end;

function TModem.gsmDecode7bit(s: string): string;
var
  OctetStr: string;
  OctetBin: string;
  Charbin: string;
  PrevOctet: string;
  Counter: integer;
  Counter2: integer;
begin
  PrevOctet := '';
  Result := '';

  for Counter:=1 to length(s) do
  begin
    if length(PrevOctet)>=7 then                                                { if 7 Bit overflow on previous }
    begin
      if BinStrToInt(PrevOctet)<>0 then
        Result := Result + Chr(BinStrToInt(PrevOctet))
      else
        Result := Result + ' ';

      PrevOctet := '';
    end;

    if Odd(Counter) then                                                        { only take two nibbles at a time }
    begin
      OctetStr := Copy(s, Counter, 2);
      OctetBin := HexToBin(OctetStr);

      Charbin := '';
      for Counter2:=1 to length(PrevOctet) do
        Charbin := Charbin + PrevOctet[Counter2];

      for Counter2:=1 to 7-length(PrevOctet) do
        Charbin := OctetBin[8-Counter2+1] + Charbin;

      if BinStrToInt(Charbin)<>0 then
        Result := Result + Chr(BinStrToInt(CharBin))
      else
        Result := Result + ' ';

      PrevOctet := Copy(OctetBin, 1, length(PrevOctet)+1);
    end;
  end;
end;

function TModem.ATCommandTest: boolean;
var
  ATCommand, ReadData: string;
begin
  Result := False;

  if not IsOpen then Exit;

  //AT指令
  ATCommand := 'AT' + ENTER_KEY_FLAG;
  
  try
    if not PublicFun.FSemaphoreManager.Lock then Exit;
    if not WriteAndWaitRead(ATCommand, ReadData) then Exit;
  finally
    PublicFun.FSemaphoreManager.Unlock;
  end;

  if pos('OK', UpperCase(Trim(ReadData)))<=0 then Exit;
  
  Result := True;
end;

function TModem.GetModemStatus: string;
begin
  if ATCommandTest then
    Result := COMM_OPEN_STATUS
  else
    Result := COMM_STOP_STATUS;
end;

end.