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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
atcmd.c
资源名称：de8681_w.zip　[点击查看]
上传用户：sdttscl
上传日期：2010-01-04
资源大小：683k
文件大小：19k
源码类别：

Modem编程

开发平台：

C/C++

atcmd.c：源码内容
  1. //---------------------------------------------------------------------------------------------------
  2. // Project:- DE8681
  3. //   Filename:- ATCMD.C
  4. // Description:- Routines for AT Command Functions and Interpretation.
  5. // Programmer:- D.T.F
  6. // Version:- 2.0
  7. // Created:- 28th February 2002
  8. // Last modified:-
  9. //---------------------------------------------------------------------------------------------------
  10. // (C) Consumer Microcircuits Ltd 2002
  11. //
  12. // This firmware was designed by:-
  13. // Consumer Microcircuits Ltd,
  14. // Langford, Maldon,
  15. // ESSEX
  16. // CM9 6WG.
  17. // in the UK for use with CML evaluation kits only and is based on UK originated technology.
  18. // Please contact
  19. // sales@cmlmicro.co.uk
  20. // +44 (0)1621 875500
  21. // for licensing details.
  22. //---------------------------------------------------------------------------------------------------
  24. #define ATCMD_C
  26. #include "ef8681.h"
  28. unsigned char atcmd_interpret(void)
  29. {
  30. unsigned char retval;
  32. ATBUFPTR = 0;
  34. while (ATBUF[ATBUFPTR] != NUL) // Check if NULL encountered to indicate end of AT command.
  35. {
  37. switch(ATBUF[ATBUFPTR])
  38. {
  39. case 'A': case 'a':
  40. retval = atacmd(); // Routine sets Answer flag in S register
  41. // AT Command Mode Flag cleared to indicate Handshaking
  42. break;
  43. case 'B': case 'b':
  44. retval = atbcmd(); // Routine to control communication standard
  45. break;
  46. case 'D': case 'd':
  47. retval = atdcmd(); // Routine to extract DTMF digits and set Call flag in S register
  48. // AT Command Mode Flag cleared to indicate Handshaking
  49. break;
  50. case 'E': case'e':
  51. retval = atecmd(); // Routine to control echo
  52. break;
  53. case 'H': case'h':
  54. retval = athcmd(); // Routine to control hook swicth
  55. break;
  56. case 'I': case'i':
  57. retval = aticmd(); // Routine to provide user product information
  58. break;
  59. case 'N': case'n':
  60. retval = atncmd(); // Routine to enable/disable modulation fallback
  61. break;
  62. case 'O': case'o':
  63. retval = atocmd(); // Routine to revert back to online mode
  64. break;
  65. case 'Q': case'q':
  66. retval = atqcmd(); // Routine to control Modem responses
  67. break;
  68. case 'S': case's':
  69. retval = atscmd(); // Routine to write or read S-Registers
  70. break;
  71. case 'V': case'v':
  72. retval = atvcmd(); // Routine to control result code format
  73. break;
  74. case 'X': case'x':
  75. retval = atxcmd(); // Routine to control calling characteristics
  76. break;
  77. case 'Z': case'z':
  78. retval = atzcmd(); // Routine to reset modem and restore factory profiles
  79. break;
  80. case '&':
  81. retval = xatcmd(); // Routine to excute extended AT Commands
  82. break;
  83. case '@':
  84. retval = cmlatcmd(); // Routine to excute CML specific AT Commands
  85. break;
  86. default:
  87. retval = ERROR;
  88. break;
  89. }
  91. // If an error occurs during interpretation
  92. // or Manual Answer or Dial has been requested
  93. // AT Command interpretation will be terminated
  95. if (retval != OK)
  96. {
  97. return (retval);
  98. }
  100. ATBUFPTR++; // Increment AT Command Buffer pointer.
  101. }
  102. return (OK); // Intepretation has completed successfully or no commands had been entered.
  103. }
  106. unsigned char atacmd(void)
  107. {
  108. ATCMDMODE = 0;
  109. ANSORIG = 0; // Set to indicate answering
  111. return (NORESULT);
  112. }
  114. unsigned char atbcmd(void) // Modify Call Characteristic bits located in S27 reg
  115. {
  116. unsigned char tempreg;
  118. ATBUFPTR++; // Increment AT Command Buffer pointer.
  120. switch(ATBUF[ATBUFPTR])
  121. {
  122. case '0':
  123. tempreg = PROTB0;
  124. break;
  125. case '1':
  126. tempreg = PROTB1;
  127. break;
  128. case '2':
  129. tempreg = PROTB2;
  130. break;
  131. case '3':
  132. tempreg = PROTB3;
  133. break;
  134. case '4':
  135. tempreg = PROTB4;
  136. break;
  137. case '5':
  138. tempreg = PROTB5;
  139. break;
  140. case '6':
  141. tempreg = PROTB6;
  142. break;
  143. case '7':
  144. tempreg = PROTB7;
  145. break;
  146. case '8':
  147. tempreg = PROTB8;
  148. break;
  149. case '9':
  150. tempreg = PROTB9;
  151. break;
  152. default:
  153. return (ERROR); // Return ERROR to indicate invalid character
  154. }
  155. S27 &= 0b00001111; // Clear existing Protocol settings 
  157. S27 ^= tempreg; // Modify S27 to reflect new settings
  159. return (OK); // Return OK to indicate success
  160. }
  162. unsigned char atdcmd(void)
  163. {
  164. unsigned char i, tmp;
  166. ATBUFPTR++; // Increment AT Command Buffer pointer.
  168. tmp = ATBUF[ATBUFPTR]; // Load temporary character register
  170. if ((tmp == 'L') || (tmp == 'l'))
  171. {
  172. if (TELNUM[0] != NUL)
  173. {
  174. ATCMDMODE = 0; // Clear AT Command Mode Flag
  175. ANSORIG = 1; // Set to indicate originate
  176. return (NORESULT); // Return NORESULT to indicate success without result code.
  177. }
  178. else
  179. {
  180. return (ERROR); // Return ERROR to indicate no previous telephone number exists
  181. }
  182. }
  184. i = 0;
  186. while ((tmp <= '9' && tmp >= '0') || (tmp <= 'D' && tmp >= 'A')
  187. || (tmp <= 'd' && tmp >= 'a') || tmp == '#' || tmp == '*' || tmp == ',')
  188. {
  189. TELNUM[i++] = tmp; // Load character into telephone digit buffer
  191. if (i >= maxteldigits)
  192. {
  193. TELNUM[0] = NUL; // Destroy previous loaded digits due to error
  194. return(ERROR); // Return ERROR to indicate telephone digit buffer is full
  195. }
  197. ATBUFPTR++; // Increment AT Command Buffer pointer.
  199. tmp = ATBUF[ATBUFPTR]; // Load temporary character register
  200. }
  202. if (i > 0)
  203. {
  204. ATBUFPTR--; // Decrement AT Command Buffer pointer (not essential because interpreter will be terminated)
  205. TELNUM[i] = NUL; // Null terminate telephone digit string
  206. ATCMDMODE = 0; // Clear AT Command Mode Flag
  207. ANSORIG = 1; // Set to indicate originate
  208. return(NORESULT); // Return NORESULT to indicate success without result code.
  209. }
  210. else
  211. {
  212. return (ERROR); // Return ERROR to indicate no previous telephone number exists
  213. }
  214. }
  216. unsigned char atecmd(void) // Modify Echo Character bit located in S14 reg
  217. {
  218. ATBUFPTR++; // Increment AT Command Buffer pointer.
  220. switch(ATBUF[ATBUFPTR])
  221. {
  222. case '0':
  223. ECHO = OFF; // Disable Echoing
  224. break;
  225. case '1':
  226. ECHO = ON; // Enable Echoing
  227. break;
  228. default:
  229. return (ERROR); // Return ERROR to indicate invalid character
  230. }
  231. return (OK); // Return OK to indicate success
  232. }
  234. unsigned char athcmd(void) // Hook switch control
  235. {
  236. ATBUFPTR++; // Increment AT Command Buffer pointer.
  238. switch(ATBUF[ATBUFPTR])
  239. {
  240. case '0':
  241. hook(0); // On-Hook
  242. break;
  243. case '1':
  244. hook(1); // Off-Hook
  245. break;
  246. default:
  247. return (ERROR); // Return ERROR to indicate invalid character
  248. }
  249. return (OK); // Return OK to indicate success
  250. }
  252. unsigned char aticmd(void) // Send information to terminal
  253. {
  254. ATBUFPTR++; // Increment AT Command Buffer pointer.
  256. switch(ATBUF[ATBUFPTR])
  257. {
  258. case '0':
  259. genmsgtopc(idmsg); // Send id message to terminal
  260. break;
  261. case '1':
  262. genmsgtopc(prodmsg); // Send product message to terminal
  263. break;
  264. case '2':
  265. genmsgtopc(cmlukmsg); // Send CML UK message to terminal
  266. genmsgtopc(cmlukwwwmsg); // Send CML UK Web address message to terminal
  267. genmsgtopc(cmlukemmsg); // Send CML UK Email address message to terminal
  268. genmsgtopc(cmluktelmsg); // Send CML UK Telephone message to terminal
  269. break;
  270. case '3':
  271. genmsgtopc(cmlsgmsg); // Send CML Singapore message to terminal
  272. genmsgtopc(cmlsgemmsg); // Send CML Singapore Email address message to terminal
  273. break;
  274. case '4':
  275. genmsgtopc(mxcommsg); // Send MX-COM message to terminal
  276. genmsgtopc(mxcomemmsg); // Send MXCOM Email address message to terminal
  277. break;
  278. default:
  279. return (ERROR); // Return ERROR to indicate invalid character
  280. }
  281. return (OK); // Return OK to indicate success
  282. }
  284. unsigned char atncmd(void)
  285. {
  286. ATBUFPTR++; // Increment AT Command Buffer pointer.
  288. switch(ATBUF[ATBUFPTR])
  289. {
  290. case '0':
  291. FALLBACK = OFF; // Disable Modulation Fallback
  292. break;
  293. case '1':
  294. FALLBACK = ON; // Enable Modulation Fallback
  295. break;
  296. default:
  297. return (ERROR); // Return ERROR to indicate invalid character
  298. }
  299. return (OK); // Return OK to indicate success
  300. }
  302. unsigned char atocmd(void)
  303. {
  304. DATAXFER = 1; // Revert back to online data transfer mode
  305. ATCMDMODE = 0;
  306. return (NORESULT);
  307. }
  309. unsigned char atqcmd(void) // Modify Response bit located in S14 reg
  310. {
  311. ATBUFPTR++; // Increment AT Command Buffer pointer.
  313. switch(ATBUF[ATBUFPTR])
  314. {
  315. case '0':
  316. RESOFF = FALSE; // Enable result code responses
  317. break;
  318. case '1':
  319. RESOFF = TRUE; // Disable result code responses
  320. break;
  321. default:
  322. return (ERROR); // Return ERROR to indicate invalid character
  323. }
  324. return (OK); // Return OK to indicate success
  325. }
  327. unsigned char atscmd(void)
  328. {
  329. unsigned long i;
  331. unsigned char k=0;
  333. char tempbuf[3];
  335. volatile unsigned char bank2 * sregptr;
  337. unsigned char sreg_offset;
  339. ATBUFPTR++; // Increment AT Command Buffer pointer.
  341. if ((ATBUF[ATBUFPTR] > '9') || (ATBUF[ATBUFPTR] < '0'))
  342. {
  343. return(ERROR);
  344. }
  346. tempbuf[k++] = ATBUF[ATBUFPTR++];
  348. if ((ATBUF[ATBUFPTR] <= '9') && (ATBUF[ATBUFPTR] >= '0'))
  349. {
  350. tempbuf[k++] = ATBUF[ATBUFPTR++];
  351. }
  352. tempbuf[k] = NUL;
  354. sreg_offset = (atoi(tempbuf)) & 0xFF; // Convert ASCII decimal to integer
  356. if (sreg_offset >= numsregs) // Return ERROR if offset exceeds max value
  357. { // specified in header file
  358. return(ERROR);
  359. }
  361. sregptr = &S0;
  362. sregptr += sreg_offset;
  364. if (ATBUF[ATBUFPTR] == '=')
  365. {
  366. ATBUFPTR++; // Increment AT Command Buffer pointer.
  368. i = ascregtolong();
  369. if (i > 255) // If 8-bit register exceeds 255 return error.
  370. {
  371. return (ERROR);
  372. }
  373. *sregptr = i;
  374. }
  375. else if (ATBUF[ATBUFPTR] == '?')
  376. {
  377. if (HEXOP)
  378. {
  379. hexnum2scrn(*sregptr,2,WORDRES); // Send LF char if word results enabled
  380. }
  381. else
  382. {
  383. decnum2scrn(*sregptr,3,WORDRES); // Send LF char if word results enabled
  384. }
  385. }
  386. else
  387. {
  388. return (ERROR); // Return ERROR to indicate invalid character
  389. }
  390. return (OK); // Return OK to indicate success
  391. }
  393. unsigned char atvcmd(void) // Modify Word Response bit located in S14 reg
  394. {
  395. ATBUFPTR++; // Increment AT Command Buffer pointer.
  397. switch(ATBUF[ATBUFPTR])
  398. {
  399. case '0':
  400. WORDRES = OFF; // Enable number responses
  401. break;
  402. case '1':
  403. WORDRES = ON; // Enable Word responses
  404. break;
  405. default:
  406. return (ERROR); // Return ERROR to indicate invalid character
  407. }
  408. return (OK); // Return OK to indicate success
  409. }
  411. unsigned char atxcmd(void) // Modify Call Characteristic bits located in S22 reg
  412. {
  413. unsigned char tempreg;
  415. ATBUFPTR++; // Increment AT Command Buffer pointer.
  417. switch(ATBUF[ATBUFPTR])
  418. {
  419. case '0':
  420. tempreg = X0CALLING;
  421. break;
  422. case '1':
  423. tempreg = X1CALLING;
  424. break;
  425. case '2':
  426. tempreg = X2CALLING;
  427. break;
  428. case '3':
  429. tempreg = X3CALLING;
  430. break;
  431. case '4':
  432. tempreg = X4CALLING;
  433. break;
  434. default:
  435. return (ERROR); // Return ERROR to indicate invalid character
  436. }
  437. S22 &= 0b00011111; // Clear existing calling characteristics 
  439. S22 ^= tempreg; // Modify S22 to reflect new settings
  441. return (OK); // Return OK to indicate success
  442. }
  444. unsigned char atzcmd(void) // Reset Modem and recall factory profile
  445. {
  446. ATBUFPTR++; // Increment AT Command Buffer pointer.
  448. switch(ATBUF[ATBUFPTR])
  449. {
  450. case '0':
  451. init_sregs(0); // Recall factory profile 0.
  452. break;
  453. case '1':
  454. init_sregs(1); // Recall factory profile 1.
  455. break;
  456. default:
  457. return (ERROR); // Return ERROR to indicate invalid character
  458. }
  459. reset_cbus(); // Perform CMX868 General reset and clear device write shadow registers
  460. return (OK); // Return OK to indicate success
  461. }
  463. unsigned char xatcmd(void)
  464. {
  465. ATBUFPTR++; // Increment AT Command Buffer pointer.
  467. switch(ATBUF[ATBUFPTR])
  468. {
  469. case 'F': case 'f':
  470. return (xatfcmd());
  471. case 'G': case 'g':
  472. return (xatgcmd());
  473. default:
  474. return (ERROR);
  475. }
  476. }
  478. unsigned char xatfcmd(void) // Recall factory profile
  479. {
  480. ATBUFPTR++; // Increment AT Command Buffer pointer.
  482. switch(ATBUF[ATBUFPTR])
  483. {
  484. case '0':
  485. init_sregs(0); // Recall factory profile 0.
  486. break;
  487. case '1':
  488. init_sregs(1); // Recall factory profile 1.
  489. break;
  490. default:
  491. return (ERROR); // Return ERROR to indicate invalid character
  492. }
  493. return (OK); // Return OK to indicate success
  494. }
  496. unsigned char xatgcmd(void) // Modify Guard Tone bits located in S23 reg
  497. {
  498. unsigned char tempreg;
  500. ATBUFPTR++; // Increment AT Command Buffer pointer.
  502. switch(ATBUF[ATBUFPTR])
  503. {
  504. case '0':
  505. tempreg = NOGUARD;
  506. break;
  507. case '1':
  508. tempreg = GUARD550;
  509. break;
  510. case '2':
  511. tempreg = GUARD1800;
  512. break;
  513. default:
  514. return (ERROR); // Return ERROR to indicate invalid character
  515. }
  516. S23 &= 0b00111111; // Clear existing Guard tone settings 
  518. S23 ^= tempreg; // Modify S23 to reflect new settings
  520. return (OK); // Return OK to indicate success
  521. }
  523. unsigned char cmlatcmd(void)
  524. {
  526. ATBUFPTR++; // Increment AT Command Buffer pointer.
  528. switch(ATBUF[ATBUFPTR])
  529. {
  530. case 'F': case 'f': // CML Test Functions
  531. return (cmlatfcmd());
  532. case 'R': case 'r':
  533. return (cmlatrcmd());
  534. default:
  535. return (ERROR);
  536. }
  537. }
  539. unsigned char cmlatfcmd(void) // CML Test Functions
  540. {
  541. ATBUFPTR++; // Increment AT Command Buffer pointer.
  543. switch(ATBUF[ATBUFPTR])
  544. {
  545. case '0':
  546. PORTA = 0b00010000; // Turn off DCDIND LED
  547. PORTB |= 0b00000110; // Ensure RIN and DCDN o/p's are set
  548. hook(0); // On-Hook (Hook LED off)
  549. LED_OVERRIDE = 0;
  550. break;
  551. case '1':
  552. PORTA = 0b00001111; // Turn on DCDIND, RXDIND, TXDIND, DTRIND and HOOK LEDs
  553. PORTB &= 0b11111001; // Clear RIN and DCDN o/p's
  554. hook(1); // Off-Hook (Hook LED on)
  555. LED_OVERRIDE = 1;
  556. break;
  557. case '2':
  558. DelayMs(100); // Wait 100ms
  559. break;
  560. case '3':
  561. Delay1s(1); // Wait 1s
  562. break;
  563. case '4':
  564. T0IE = 0; // Initially disable Timer interrupt
  565. BERTEND = 0; // BERT Rx End
  566. BERTFLAG = 1; // Set BERT Flag
  567. break;
  568. case '5':
  569. T0IE = 0; // Initially disable Timer interrupt
  570. BERTEND = 1; // BERT Tx End
  571. BERTFLAG = 1; // Set BERT Flag
  572. break;
  573. case '6':
  574. TESTFUNC1 = 1; // Set Test Function One flag
  575. break;
  576. case '7':
  577. GPT6 = 30; // Load GPT6 for 30 second
  579. while (PICIRQN != 0)
  580. {
  581. if (GPT6 == 0)
  582. {
  583. return (ERROR); // Return ERROR to indicate invalid character
  584. }
  585. }
  586. CMXSTAT = rd16_cbus(CMXSTAT_ADDR); // Update CMX868 Status Shadow register
  588. if (HEXOP)
  589. {
  590. hexnum2scrn(CMXSTAT,4,WORDRES); // Send LF char if word results enabled
  591. }
  592. else
  593. {
  594. decnum2scrn(CMXSTAT,5,WORDRES); // Send LF char if word results enabled
  595. }
  596. break;
  597. case '8':
  598. return (NYI); // Return NYI to indicate function not implemented yet
  599. case '9':
  600. return (NYI); // Return NYI to indicate function not implemented yet
  601. default:
  602. return (ERROR); // Return ERROR to indicate invalid character
  603. }
  604. return (OK); // Return OK to indicate success
  605. }
  607. unsigned char cmlatrcmd(void)
  608. {
  609. unsigned int j;
  611. unsigned long i;
  613. volatile unsigned char bank3 * byteregptr;
  615. volatile unsigned int bank3 * wordregptr;
  617. unsigned char cbus_addr, reg16bit, writereg;
  619. ATBUFPTR++; // Increment AT Command Buffer pointer.
  621. switch(ATBUF[ATBUFPTR])
  622. {
  623. case 'E': case 'e':
  625. ATBUFPTR++; // Increment AT Command Buffer pointer.
  627. reg16bit = 1; // Assume 16 bit word unless modified
  628. writereg = 1; // Assume write register unless modified
  630. switch(ATBUF[ATBUFPTR])
  631. {
  632. case '0':
  633. cbus_addr = CMXGENCTRL_ADDR;
  634. wordregptr = &CMXGENCTRL;
  635. break;
  636. case '1':
  637. cbus_addr = CMXTXMODE_ADDR;
  638. wordregptr = &CMXTXMODE;
  639. break;
  640. case '2':
  641. cbus_addr = CMXRXMODE_ADDR;
  642. wordregptr = &CMXRXMODE;
  643. break;
  644. case '3':
  645. reg16bit = 0;
  646. cbus_addr = CMXTXDATA_ADDR;
  647. byteregptr = &CMXTXDATA;
  648. break;
  649. case '4':
  650. reg16bit = 0;
  651. cbus_addr = CMXTXDATAV14_ADDR;
  652. byteregptr = &CMXTXDATAV14;
  653. break;
  654. case '5':
  655. writereg = 0;
  656. reg16bit = 0;
  657. cbus_addr = CMXRXDATA_ADDR;
  658. byteregptr = &CMXRXDATA;
  659. break;
  660. case '6':
  661. writereg = 0;
  662. cbus_addr = CMXSTAT_ADDR;
  663. wordregptr = &CMXSTAT;
  664. break;
  665. case '8':
  666. cbus_addr = CMXPROG_ADDR;
  667. wordregptr = &CMXPROG;
  668. break;
  669. case '9':
  670. cbus_addr = CMXTESTADDR_ADDR;
  671. wordregptr = &CMXTESTADDR;
  672. break;
  673. case 'A': case 'a':
  674. cbus_addr = CMXTESTWR_ADDR;
  675. wordregptr = &CMXTESTWR;
  676. break;
  677. case 'B': case 'b':
  678. writereg = 0;
  679. cbus_addr = CMXTESTRD_ADDR;
  680. wordregptr = &CMXTESTRD;
  681. break;
  682. default:
  683. return (ERROR);
  684. }
  686. ATBUFPTR++; // Increment AT Command Buffer pointer.
  688. if ((ATBUF[ATBUFPTR] == '=') && writereg)
  689. {
  690. ATBUFPTR++; // Increment AT Command Buffer pointer.
  692. i = ascregtolong();
  693. if ((i > 65535) || (!reg16bit && (i > 255))) // If 8-bit register and value exceeds 255 return error.
  694. {
  695. return (ERROR);
  696. }
  698. if (reg16bit)
  699. {
  700. *wordregptr = i & 0xFFFF;
  701. wr16_cbus(cbus_addr,*wordregptr);
  702. }
  703. else
  704. {
  705. *byteregptr = i & 0xFF;
  706. wr_cbus(cbus_addr,*byteregptr);
  707. }
  708. break;
  709. }
  710. else if ((ATBUF[ATBUFPTR] == '?'))
  711. {
  712. if (reg16bit)
  713. {
  714. if (!writereg) // Read CBUS if 16 bit read register 
  715. {
  716. *wordregptr = rd16_cbus(cbus_addr); // Place CBUS reply data into shadow register
  717. }
  718. j = *wordregptr & 0xFFFF; // Copy 16 bit shadow register
  719. }
  720. else
  721. {
  722. if (!writereg) // Read CBUS if 8 bit read register 
  723. {
  724. *byteregptr = rd_cbus(cbus_addr); // Place CBUS reply data into shadow register
  725. }
  726. j = *byteregptr & 0xFF; // Copy 8 bit shadow register
  727. }
  729. if (HEXOP)
  730. {
  731. hexnum2scrn(j,4,WORDRES); // Send LF char if word results enabled
  732. }
  733. else
  734. {
  735. decnum2scrn(j,5,WORDRES); // Send LF char if word results enabled
  736. }
  737. break;
  738. }
  739. else
  740. {
  741. return (ERROR);
  742. }
  743. case 'R': case 'r':
  744. reset_cbus(); // Perform CMX868 General Reset and clear device write shadow registers
  745. break;
  746. default:
  747. return (ERROR);
  748. }
  749. return (OK); // Return OK to indicate success
  750. }
  752. unsigned long ascregtolong(void)
  753. {
  754. unsigned char tempbuf[6];
  756. unsigned long tempnum=0;
  758. unsigned long j=1;
  760. signed char i,k;
  762. i=0;
  764. // Loop while characters are decimal digits  
  765. // and are no more than 5 digits long i.e. 65535
  767. while ((ATBUF[ATBUFPTR] <= '9') && (ATBUF[ATBUFPTR] >= '0') && (i < 6))
  768. {
  769. tempbuf[i++] = ATBUF[ATBUFPTR++];
  770. }
  772. ATBUFPTR--;
  774. i--;
  776. for (k=i;k>=0;k--)
  777. {
  778. tempnum += (tempbuf[k] - 0x30) * j;
  779. j *= 10;
  780. }
  782. return (tempnum);
  783. }