开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
ATcmdSet.c
资源名称：VsonBryanFaxConexant070517.rar　[点击查看]
上传用户：xhjmsc
上传日期：2019-09-13
资源大小：389k
文件大小：17k
源码类别：

传真(Fax)编程

开发平台：

C/C++

ATcmdSet.c：源码内容
  2. #include "includeH.h"
  5. void SendATcmdModemSoftReset(void)                    //
  6. {       
  7.         unsigned char ucGeneralCnt=0,ATcmdSoftReset[]={0x41,0x54,0x5a,0x0d}; //add a ";" , a bug of Jan. 9,2007
  8.         unsigned int wGeneralCount=0;
  9.         gwTxNum=sizeof (ATcmdSoftReset);
  10.         gpucTxBufPnt=0;
  11.         
  12.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  13.         {
  14.           aucUartTxBuf[ucGeneralCnt]=ATcmdSoftReset[ucGeneralCnt];          
  15.         }               
  16.                       
  17.         TXBUF0=aucUartTxBuf[0];    
  18.         gucTxBufCnt=1;
  19.         while (wGeneralCount++<0xffff)    
  20.         {
  21.           if ((aucUartRxBuf[gucUartRxCnt-2]==0x0d)&&(aucUartRxBuf[gucUartRxCnt-3]==0x4B))
  22.             break;
  23.           
  24.         //if check time>min. 5S, Receive Fax error, progra should be quit  
  25.         //RxFaxTimeOverflowErrorQuit();
  26.         }     
  27. }    
  29. void SendATcmd(void)                    //
  30. {       
  31.         unsigned char ucGeneralCnt=0,ATcmdPrefix[]={0x41,0x54,0x0d};
  32.         gwTxNum=sizeof (ATcmdPrefix);
  33.         gpucTxBufPnt=0;
  34.         
  35.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  36.         {
  37.           aucUartTxBuf[ucGeneralCnt]=ATcmdPrefix[ucGeneralCnt];          
  38.         }               
  39.                       
  40.         TXBUF0=aucUartTxBuf[0];    
  41.         gucTxBufCnt=1; 
  42. }    
  44. void SendATcmdPrefix(void)                    //
  45. {       
  46.         unsigned char ucGeneralCnt=0,ATcmdPrefix[]={0x41,0x54};
  47.         gwTxNum=sizeof (ATcmdPrefix);
  48.         gpucTxBufPnt=0;
  49.         
  50.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  51.         {
  52.           aucUartTxBuf[ucGeneralCnt]=ATcmdPrefix[ucGeneralCnt];          
  53.         }               
  54.                       
  55.         TXBUF0=aucUartTxBuf[0];    
  56.         gucTxBufCnt=1; 
  57. }    
  59. void SendATcmdSuffix(void)                    //
  60. {       
  61.         unsigned char ucGeneralCnt=0,ATcmdSuffix[]={0x0D};
  62.         gwTxNum=sizeof (ATcmdSuffix);
  63.         gpucTxBufPnt=0;
  64.         
  65.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  66.         {
  67.           aucUartTxBuf[ucGeneralCnt]=ATcmdSuffix[ucGeneralCnt];          
  68.         }               
  69.                       
  70.         TXBUF0=aucUartTxBuf[0];    
  71.         gucTxBufCnt=1;
  72. }
  73.   
  74. void SendATconfigFS0(void)
  75. {       
  76.         unsigned char ucGeneralCnt=0,
  77.         ATFS0[] = {0x41,0x54,0x26,0x46,0x53,0x30,0x3d,0x30,0x45,0x31,0x56,0x31,0x51,0x30,0X0d};
  78.         gwTxNum=sizeof (ATFS0);
  79.         gpucTxBufPnt=0;
  80.         
  81.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  82.         {
  83.           aucUartTxBuf[ucGeneralCnt]=ATFS0[ucGeneralCnt];          
  84.         }               
  85.                       
  86.         TXBUF0=aucUartTxBuf[0];    
  87.         gucTxBufCnt=1; 
  88. }
  90. void SendATconfigS7(void)
  91. {       
  92.         unsigned char ucGeneralCnt=0,
  93.         //ATS7[] = {0x41,0x54,0x53,0x37,0x3d,0x36,0x30,0x26,0x44,0x33,0x26,
  94.         //0x4b,0x34,0x5c,0x51,0x31,0x5c,0x4a,0x30,0x0d};//Ambient
  95.         ATS7[] = {0x41,0x54,0x53,0x37,0x3d,0x36,0x30,0x26,0x44,0x33,0x26,0x4b,0x34,0x0d};//Conexant
  96.         gwTxNum=sizeof (ATS7);
  97.         gpucTxBufPnt=0;
  98.         
  99.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  100.         {
  101.           aucUartTxBuf[ucGeneralCnt]=ATS7[ucGeneralCnt];          
  102.         }               
  103.                       
  104.         TXBUF0=aucUartTxBuf[0];    
  105.         gucTxBufCnt=1; 
  106. }     
  108. void SendATconfigX4M1(void)
  109. {       
  110.         unsigned char ucGeneralCnt=0,ATX4M1L0[] = {0x41,0x54,0x58,0x34,0x4d,0x31,0x4c,0x30,0x0d};
  111.         gwTxNum= sizeof (ATX4M1L0);
  112.         gpucTxBufPnt=0;
  113.         
  114.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  115.         {
  116.           aucUartTxBuf[ucGeneralCnt]=ATX4M1L0[ucGeneralCnt];          
  117.         }               
  118.                       
  119.         TXBUF0=aucUartTxBuf[0];    
  120.         gucTxBufCnt=1; 
  121. }     
  124. void SendATconfigFE0EndofRX(void)
  125. {       
  126.         unsigned char ucGeneralCnt=0;
  127.         //Ambient
  128.         //unsigned char ATFE0EndofRX[] = {0x41,0x54,0x26, 0x46, 0x45, 0x31, 0x56, 0x31, 0x57, 0x32, 0x26, 0x44, 0x32, 0x26, 0x43, 
  129.                                       //0x31, 0x53, 0x30, 0x3d, 0x30, 0x2d, 0x43, 0x30, 0x0d};  // 26 is different of 2b a bug of Sep. 22
  130.         //Conexant
  131.         unsigned char ATFE0EndofRX[] = {0x41,0x54,0x26, 0x46, 0x45, 0x30, 0x56, 0x31, 0x26, 0x43, 0x31, 0x26, 0x44, 
  132.                                       0x32, 0x53, 0x39, 0x35, 0x3d, 0x34, 0x37, 0x53, 0x30, 0x3d, 0x30,0x0d};  // 26 is different of 2b a bug of Sep. 22
  133.         gwTxNum=sizeof (ATFE0EndofRX);
  134.         gpucTxBufPnt=0;
  135.         
  136.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  137.         {
  138.           aucUartTxBuf[ucGeneralCnt]=ATFE0EndofRX[ucGeneralCnt];          
  139.         }               
  140.                       
  141.         TXBUF0=aucUartTxBuf[0];    
  142.         gucTxBufCnt=1; 
  143. }
  145. void SendATconfigS7RX(void)
  146. {       
  147.         unsigned char ucGeneralCnt=0;
  148.         unsigned char ATS7RX[] = {0x41,0x54,0x53,0x37,0x3d,0x36,0x30,
  149.          0x4c,0x30,0x4d,0x31,0x26,0x4b,0x33,0x4e,0x31,0x58,0x34,0x0d};
  150.         gwTxNum=sizeof (ATS7RX);
  151.         gpucTxBufPnt=0;
  152.         
  153.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  154.         {
  155.           aucUartTxBuf[ucGeneralCnt]=ATS7RX[ucGeneralCnt];          
  156.         }               
  157.                       
  158.         TXBUF0=aucUartTxBuf[0];    
  159.         gucTxBufCnt=1; 
  160. }     
  162. void SendATconfigS0RX(void)
  163. {       
  164.         unsigned char ucGeneralCnt=0,ATS0RX[]={0x41,0x54,0x53,0x30,0x3d,0x30,0x0d};
  165.         gwTxNum=sizeof (ATS0RX);
  166.         gpucTxBufPnt=0;
  167.         
  168.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  169.         {
  170.           aucUartTxBuf[ucGeneralCnt]=ATS0RX[ucGeneralCnt];          
  171.         }               
  172.                       
  173.         TXBUF0=aucUartTxBuf[0];    
  174.         gucTxBufCnt=1; 
  175. }     
  177. void SendATcmdFCLASS0(void)
  178. {       
  179.         unsigned char ucGeneralCnt=0,
  180.         FCLASS0[]={0x41,0x54,0x2b,0x46,0x43,0x4c,0x41,0x53,0x53,0x3d,0x30,0x0d};
  181.         gwTxNum=sizeof (FCLASS0);
  182.         gpucTxBufPnt=0;
  183.         
  184.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  185.         {
  186.           aucUartTxBuf[ucGeneralCnt]=FCLASS0[ucGeneralCnt];//a bug of Sep. 21 Fclass---->Fclass0          
  187.         }               
  188.                       
  189.         TXBUF0=aucUartTxBuf[0];    
  190.         gucTxBufCnt=1; 
  191. }     
  193. void SendATcmdFCLASS(void)
  194. {       
  195.         unsigned char ucGeneralCnt=0,
  196.         FCLASS[]={0x41,0x54,0x2b,0x46,0x43,0x4c,0x41,0x53,0x53,0x3d,0x31,0x0d};
  197.         gwTxNum=sizeof (FCLASS);
  198.         gpucTxBufPnt=0;
  199.         
  200.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  201.         {
  202.           aucUartTxBuf[ucGeneralCnt]=FCLASS[ucGeneralCnt];          
  203.         }               
  204.                       
  205.         TXBUF0=aucUartTxBuf[0];    
  206.         gucTxBufCnt=1; 
  207. }     
  208.      
  209. void SendATcmdDT(void)                    //ATDT
  210. {       
  211.         unsigned char ucGeneralCnt=0,
  212.                       DT[]={0x41,0x54,0x44,0x54,0x39,0x36,0x31,0x31,0x33,0x39,0x35,0x30,0x39,0x0d};
  213.         gwTxNum=sizeof (DT);
  214.         gpucTxBufPnt=0;
  215.         
  216.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  217.         {
  218.           aucUartTxBuf[ucGeneralCnt]=DT[ucGeneralCnt];          
  219.         }               
  220.                       
  221.         TXBUF0=aucUartTxBuf[0];    
  222.         gucTxBufCnt=1; 
  223. }    
  225. void SendATcmdFRH(void)                    //AT+FRH
  226. {       
  227.         unsigned char ucGeneralCnt=0,
  228.                       FRH[]={0x41,0x54,0x2b,0x46,0x52,0x48,0x3d,0x33,0x0d};
  229.         gwTxNum=sizeof (FRH);
  230.         gpucTxBufPnt=0;
  231.         
  232.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  233.         {
  234.           aucUartTxBuf[ucGeneralCnt]=FRH[ucGeneralCnt];          
  235.         }               
  236.                       
  237.         TXBUF0=aucUartTxBuf[0];    
  238.         gucTxBufCnt=1; 
  239. }    
  241. void SendATcmdFTH(void)                    //AT+FTH
  242. {       
  243.         unsigned char ucGeneralCnt=0,
  244.                       FTH[]={0x41,0x54,0x2b,0x46,0x54,0x48,0x3d,0x33,0x0d};
  245.         gwTxNum=sizeof (FTH);
  246.         gpucTxBufPnt=0;
  247.         
  248.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  249.         {
  250.           aucUartTxBuf[ucGeneralCnt]=FTH[ucGeneralCnt];          
  251.         }               
  252.                       
  253.         TXBUF0=aucUartTxBuf[0];    
  254.         gucTxBufCnt=1; 
  255. }    
  256. /*
  257. void SendATdataFTHNSF(void)                    //DataFTHNSF
  258. {       
  259.         unsigned char ucGeneralCnt=0;
  260.         unsigned char FTHNSF[] = {0xff,0x13,0x54,0x47,0x46,0x33,0x36,0x36,0x43,0x00,0x77,0x9C,0x10,0x03};
  261.         gwTxNum=sizeof (FTHNSF);
  262.         gpucTxBufPnt=0;
  263.         
  264.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  265.         {
  266.           aucUartTxBuf[ucGeneralCnt]=FTHNSF[ucGeneralCnt];          
  267.         }               
  268.                       
  269.         TXBUF0=aucUartTxBuf[0];    
  270.         gucTxBufCnt=1; 
  271. }    
  272. */
  273. void SendATdataFTHTSI(void)                    //DataFTHTSI
  274. {       
  275.         unsigned char ucGeneralCnt=0,
  276.                       FTHTSI[]={0xff,0x03,0x43,0x78,0x61,0x46,0x10,0x03};
  277.         gwTxNum=sizeof (FTHTSI);
  278.         gpucTxBufPnt=0;
  279.         
  280.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  281.         {
  282.           aucUartTxBuf[ucGeneralCnt]=FTHTSI[ucGeneralCnt];          
  283.         }               
  284.                       
  285.         TXBUF0=aucUartTxBuf[0];    
  286.         gucTxBufCnt=1; 
  287. }    
  289. void SendATdataFTHCSI(void)                    //DataFTHCSI
  290. {       
  291.         unsigned char ucGeneralCnt=0;//, a bug of Jan.5,2007
  292.                       //FTHCSI[]={0xff,0x03,0x40,0x20,0x20,0x20,0x20,0x20,
  293.                        //0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
  294.                        //0x36,0x33,0x38,0x10,0x03};
  295.         gwTxNum = sizeof (FTHCSI);//gwTxNum=ucDataNum;
  296.         gpucTxBufPnt=0;
  297.         
  298.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  299.         {
  300.           aucUartTxBuf[ucGeneralCnt]=FTHCSI[ucGeneralCnt];          
  301.         }               
  302.                       
  303.         TXBUF0=aucUartTxBuf[0];    
  304.         gucTxBufCnt=1; 
  305. }    
  307. void SendATdataFTHDIS(void)                    //DataFTHDIS
  308. {       
  309.         unsigned char ucGeneralCnt=0;
  310.                       //FTHDIS[]={0xff,0x13,0x80,0x00,0x46,0x78,0x10,0x03};//c6 T.4 2D
  311.         gwTxNum=sizeof (FTHDIS);
  312.         gpucTxBufPnt=0;
  313.         
  314.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  315.         {
  316.           aucUartTxBuf[ucGeneralCnt]=FTHDIS[ucGeneralCnt];          
  317.         }               
  318.                       
  319.         TXBUF0=aucUartTxBuf[0];    
  320.         gucTxBufCnt=1; 
  321. }    
  322. /*
  323. void SendATdataFTHDCS(void)                    //DataFTHDCS
  324. {       
  325.         unsigned char ucGeneralCnt=0,
  326.                       FTHDCS[]={0xff,0x13,0x83,0x00,0x46,0x78,0x10,0x03};
  327.         gwTxNum=sizeof (FTHDCS);
  328.         gpucTxBufPnt=0;
  329.         
  330.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  331.         {
  332.           aucUartTxBuf[ucGeneralCnt]=FTHDCS[ucGeneralCnt];          
  333.         }               
  334.                       
  335.         TXBUF0=aucUartTxBuf[0];    
  336.         gucTxBufCnt=1; 
  337. }
  338. */
  339. void SendATdataFTHCFR(void)                    //DataFTHCFR
  340. {       
  341.         unsigned char ucGeneralCnt=0,
  342.                       FTHCFR[]={0xff,0x13,0x84,0x10,0x03};
  343.         gwTxNum=sizeof (FTHCFR);
  344.         gpucTxBufPnt=0;
  345.         
  346.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  347.         {
  348.           aucUartTxBuf[ucGeneralCnt]=FTHCFR[ucGeneralCnt];          
  349.         }               
  350.                       
  351.         TXBUF0=aucUartTxBuf[0];    
  352.         gucTxBufCnt=1; 
  353. }
  355. void SendATdataFTHMCF(void)                    //DataFTHMCF
  356. {       
  357.         unsigned char ucGeneralCnt=0,
  358.                       FTHMCF[]={0xff,0x13,0x8C,0x10,0x03};
  359.         gwTxNum=sizeof (FTHMCF);
  360.         gpucTxBufPnt=0;
  361.         
  362.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  363.         {
  364.           aucUartTxBuf[ucGeneralCnt]=FTHMCF[ucGeneralCnt];          
  365.         }               
  366.                       
  367.         TXBUF0=aucUartTxBuf[0];    
  368.         gucTxBufCnt=1; 
  369. }
  371. void SendATdataFTHEOP(void)                    //DataFTHEOP
  372. {       
  373.         unsigned char ucGeneralCnt=0,
  374.                       FTHEOP[]={0xff,0x13,0x2f,0x10,0x03};
  375.         gwTxNum=sizeof (FTHEOP);
  376.         gpucTxBufPnt=0;
  377.         
  378.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  379.         {
  380.           aucUartTxBuf[ucGeneralCnt]=FTHEOP[ucGeneralCnt];          
  381.         }               
  382.                       
  383.         TXBUF0=aucUartTxBuf[0];    
  384.         gucTxBufCnt=1; 
  385. }     
  387. void SendATdataFTHDNC(void)                    //DataFTHDNC
  388. {       
  389.         unsigned char ucGeneralCnt=0,
  390.                       FTHDNC[]={0xff,0x13,0xfb,0x10,0x03};
  391.         gwTxNum=sizeof (FTHDNC);
  392.         gpucTxBufPnt=0;
  393.         
  394.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  395.         {
  396.           aucUartTxBuf[ucGeneralCnt]=FTHDNC[ucGeneralCnt];          
  397.         }               
  398.                       
  399.         TXBUF0=aucUartTxBuf[0];    
  400.         gucTxBufCnt=1; 
  401. } 
  402. /*
  403. void SendATcmdFTS(void)                    //
  404. {       
  405.         unsigned char ucGeneralCnt=0,
  406.                       FTS[]={0x41,0x54,0x2b,0x46,0x54,0x53,0x3d,0x38,0x0d};
  407.         gwTxNum=sizeof (FTS);
  408.         gpucTxBufPnt=0;
  409.         
  410.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  411.         {
  412.           aucUartTxBuf[ucGeneralCnt]=FTS[ucGeneralCnt];          
  413.         }               
  414.                       
  415.         TXBUF0=aucUartTxBuf[0];    
  416.         gucTxBufCnt=1; 
  417. }    
  418. */
  419. void SendATcmdFTM(void)                    //
  420. {       
  421.         unsigned char ucGeneralCnt=0,
  422.                       FTM[]={0x41,0x54,0x2b,0x46,0x54,0x4d,0x3d,0x39,0x36,0x0d};
  423.         gwTxNum=sizeof (FTM);
  424.         gpucTxBufPnt=0;
  425.         
  426.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  427.         {
  428.           aucUartTxBuf[ucGeneralCnt]=FTM[ucGeneralCnt];          
  429.         }               
  430.                       
  431.         TXBUF0=aucUartTxBuf[0];    
  432.         gucTxBufCnt=1; 
  433. }    
  435. void SendATcmdFRM(void)                    //
  436. {       
  437.         unsigned char ucGeneralCnt=0,
  438.                       FRM[]={0x41,0x54,0x2b,0x46,0x52,0x4d,0x3d,0x39,0x36,0x0d};
  439.         gwTxNum=sizeof (FRM);
  440.         gpucTxBufPnt=0;
  441.         
  442.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  443.         {
  444.           aucUartTxBuf[ucGeneralCnt]=FRM[ucGeneralCnt];          
  445.         }               
  446.                       
  447.         TXBUF0=aucUartTxBuf[0];    
  448.         gucTxBufCnt=1; 
  449. }    
  450. /*
  451. void SendATcmdFRM146(void)                    //
  452. {       
  453.         unsigned char ucGeneralCnt=0,
  454.                       FRM[]={0x41,0x54,0x2b,0x46,0x52,0x4d,0x3d,0x31,0x34,0x36,0x0d};
  455.         gwTxNum=sizeof (FRM);
  456.         gpucTxBufPnt=0;
  457.         
  458.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  459.         {
  460.           aucUartTxBuf[ucGeneralCnt]=FRM[ucGeneralCnt];          
  461.         }               
  462.                       
  463.         TXBUF0=aucUartTxBuf[0];    
  464.         gucTxBufCnt=1; 
  465. }    
  467. void SendATdataTF(void)                    //Data DLE ETX
  468. {       
  469.         unsigned char ucGeneralCnt=0,
  470.                       TerminalFlag[]={0x10,0x03};
  471.         gwTxNum=sizeof (TerminalFlag);
  472.         gpucTxBufPnt=0;
  473.         
  474.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  475.         {
  476.           aucUartTxBuf[ucGeneralCnt]=TerminalFlag[ucGeneralCnt];          
  477.         }               
  478.                       
  479.         TXBUF0=aucUartTxBuf[0];    
  480.         gucTxBufCnt=1; 
  481. }    
  482. */
  483. void SendATcmdH0(void)                    //H 0(0x30) Num 0
  484. {       
  485.         unsigned char ucGeneralCnt=0,
  486.                       H0[]={0x41,0x54,0x48,0x30,0x0d};//H0[]={0x41,0x54,0x48,0x4f,0x0d};
  487.         gwTxNum=sizeof (H0);
  488.         gpucTxBufPnt=0;
  489.         
  490.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  491.         {
  492.           aucUartTxBuf[ucGeneralCnt]=H0[ucGeneralCnt];          
  493.         }               
  494.                       
  495.         TXBUF0=aucUartTxBuf[0];    
  496.         gucTxBufCnt=1; 
  497. }                   
  499. void SendATcmdATA(void)                    //
  500. {       
  501.         unsigned char ucGeneralCnt=0,ATA[]={0x41,0x54,0x41,0x0d};
  502.         gwTxNum=sizeof (ATA);
  503.         gpucTxBufPnt=0;
  504.         
  505.         for(ucGeneralCnt=0;ucGeneralCnt<gwTxNum;ucGeneralCnt++)
  506.         {
  507.           aucUartTxBuf[ucGeneralCnt]=ATA[ucGeneralCnt];          
  508.         }               
  509.         TXBUF0=aucUartTxBuf[0];    
  510.         gucTxBufCnt=1; 
  511. }