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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
atcmd.c
资源名称：de8681_w.rar　[点击查看]
上传用户：lilishw
上传日期：2021-05-28
资源大小：1542k
文件大小：26k
源码类别：

Modem编程

开发平台：

Visual 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:-       3.0
  7. //  Created:-       28th February 2002
  8. //  Last modified:- 1/12/2003 (M.T)
  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 switch
  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
  355.     
  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.         case 'D': case 'd':
  535.             TESTFUNC2 = 1;
  536.             pwrup();                    // Leave powersave mode to allow DTMF Tx to operate
  537.             
  538.             // Set DTMF Tx Mode with S25 bits 2-0 selecting Tx Gain,
  539.             // and DTMF twist level set by S28 bits 2-0
  540.             CMXTXMODE = 0x1010 | ((S25 & 0x07) << 9) | ((S28 & 0x07) << 5);                                                      
  541.             return(OK);
  542.         default:
  543.             return (ERROR);
  544.     }
  545. }
  547. unsigned char cmlatfcmd(void)           // CML Test Functions
  548. {
  549.     ATBUFPTR++;                         // Increment AT Command Buffer pointer.
  551.     switch(ATBUF[ATBUFPTR])
  552.     {
  553.         case '0':
  554.             PORTA = 0b00010000;         // Turn off DCDIND LED
  555.             PORTB |= 0b00000110;        // Ensure RIN and DCDN o/p's are set
  556.             hook(0);                    // On-Hook (Hook LED off)
  557.             LED_OVERRIDE = 0;
  558.             break;
  559.         case '1':
  560.             PORTA = 0b00001111;         // Turn on DCDIND, RXDIND, TXDIND, DTRIND and HOOK LEDs
  561.             PORTB &= 0b11111001;        // Clear RIN and DCDN o/p's
  562.             hook(1);                    // Off-Hook (Hook LED on)
  563.             LED_OVERRIDE = 1;
  564.             break;
  565.         case '2':
  566.             DelayMs(100);               // Wait 100ms
  567.             break;
  568.         case '3':
  569.             Delay1s(1);                 // Wait 1s
  570.             break;
  571.         case '4':
  572.             T0IE = 0;                   // Initially disable Timer interrupt
  573.             BERTEND = 0;                // BERT Rx End
  574.             BERTFLAG = 1;               // Set BERT Flag
  575.             break;
  576.         case '5':
  577.             T0IE = 0;                   // Initially disable Timer interrupt
  578.             BERTEND = 1;                // BERT Tx End
  579.             BERTFLAG = 1;               // Set BERT Flag
  580.             break;
  581.         case '6':
  582.             TESTFUNC1 = 1;              // Set Test Function One flag
  583.             break;
  584.         case '7':
  585.             GPT6 = 30;                  // Load GPT6 for 30 second
  587.             while (PICIRQN != 0)
  588.             {
  589.                 if (GPT6 == 0)
  590.                 {
  591.                     return (ERROR);     // Return ERROR to indicate invalid character
  592.                 }
  593.             }
  594.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Update CMX868 Status Shadow register
  596.             if (HEXOP)
  597.             {
  598.                 hexnum2scrn(CMXSTAT,4,WORDRES); // Send LF char if word results enabled
  599.             }
  600.             else
  601.             {
  602.                 decnum2scrn(CMXSTAT,5,WORDRES); // Send LF char if word results enabled
  603.             }
  604.             break;
  605.         case '8':
  606.             return (NYI);               // Return NYI to indicate function not implemented yet
  607.         case '9':
  608.             return (NYI);               // Return NYI to indicate function not implemented yet
  609.         default:
  610.             return (ERROR);             // Return ERROR to indicate invalid character
  611.     }
  612.     return (OK);                        // Return OK to indicate success
  613. }
  615. unsigned char cmlatrcmd(void)
  616. {
  617.     unsigned int j;
  619.     unsigned long i;
  621.     volatile unsigned char bank3 * byteregptr;
  623.     volatile unsigned int bank3 * wordregptr;
  625.     unsigned char cbus_addr, reg16bit, writereg;
  627.     ATBUFPTR++;                         // Increment AT Command Buffer pointer.
  629.     switch(ATBUF[ATBUFPTR])
  630.     {
  631.         case 'E': case 'e':
  633.             ATBUFPTR++;                 // Increment AT Command Buffer pointer.
  635.             reg16bit = 1;               // Assume 16 bit word unless modified
  636.             writereg = 1;               // Assume write register unless modified
  638.             switch(ATBUF[ATBUFPTR])
  639.             {
  640.                 case '0':
  641.                     cbus_addr = CMXGENCTRL_ADDR;
  642.                     wordregptr = &CMXGENCTRL;
  643.                     break;
  644.                 case '1':
  645.                     cbus_addr = CMXTXMODE_ADDR;
  646.                     wordregptr = &CMXTXMODE;
  647.                     break;
  648.                 case '2':
  649.                     cbus_addr = CMXRXMODE_ADDR;
  650.                     wordregptr = &CMXRXMODE;
  651.                     break;
  652.                 case '3':
  653.                     reg16bit = 0;
  654.                     cbus_addr = CMXTXDATA_ADDR;
  655.                     byteregptr = &CMXTXDATA;
  656.                     break;
  657.                 case '4':
  658.                     reg16bit = 0;
  659.                     cbus_addr = CMXTXDATAV14_ADDR;
  660.                     byteregptr = &CMXTXDATAV14;
  661.                     break;
  662.                 case '5':
  663.                     writereg = 0;
  664.                     reg16bit = 0;
  665.                     cbus_addr = CMXRXDATA_ADDR;
  666.                     byteregptr = &CMXRXDATA;
  667.                     break;
  668.                 case '6':
  669.                     writereg = 0;
  670.                     cbus_addr = CMXSTAT_ADDR;
  671.                     wordregptr = &CMXSTAT;
  672.                     break;
  673.                 case '8':
  674.                     cbus_addr = CMXPROG_ADDR;
  675.                     wordregptr = &CMXPROG;
  676.                     break;
  677.                 case '9':
  678.                     cbus_addr = CMXTESTADDR_ADDR;
  679.                     wordregptr = &CMXTESTADDR;
  680.                     break;
  681.                 case 'A': case 'a':
  682.                     cbus_addr = CMXTESTWR_ADDR;
  683.                     wordregptr = &CMXTESTWR;
  684.                     break;
  685.                 case 'B': case 'b':
  686.                     writereg = 0;
  687.                     cbus_addr = CMXTESTRD_ADDR;
  688.                     wordregptr = &CMXTESTRD;
  689.                     break;
  690.                 default:
  691.                     return (ERROR);
  692.             }                   
  694.             ATBUFPTR++;             // Increment AT Command Buffer pointer.
  696.             if ((ATBUF[ATBUFPTR] == '=') && writereg)
  697.             {
  698.                 ATBUFPTR++;         // Increment AT Command Buffer pointer.
  700.                 i = ascregtolong();
  701.                 if ((i > 65535) || (!reg16bit && (i > 255)))    // If 8-bit register and value exceeds 255 return error.
  702.                 {
  703.                     return (ERROR);
  704.                 }
  706.                 if (reg16bit)
  707.                 {
  708.                     *wordregptr = i & 0xFFFF;
  709.                     wr16_cbus(cbus_addr,*wordregptr);
  710.                 }
  711.                 else
  712.                 {
  713.                     *byteregptr = i & 0xFF;                 
  714.                     wr_cbus(cbus_addr,*byteregptr);
  715.                 }
  716.                 break;
  717.             }
  718.             else if ((ATBUF[ATBUFPTR] == '?'))
  719.             {
  720.                 if (reg16bit)
  721.                 {
  722.                     if (!writereg)      // Read CBUS if 16 bit read register 
  723.                     {
  724.                         *wordregptr = rd16_cbus(cbus_addr); // Place CBUS reply data into shadow register
  725.                     }
  726.                     j = *wordregptr & 0xFFFF;           // Copy 16 bit shadow register
  727.                 }
  728.                 else
  729.                 {
  730.                     if (!writereg)      // Read CBUS if 8 bit read register 
  731.                     {
  732.                         *byteregptr = rd_cbus(cbus_addr);   // Place CBUS reply data into shadow register
  733.                     }
  734.                     j = *byteregptr & 0xFF; // Copy 8 bit shadow register
  735.                 }
  737.                 if (HEXOP)
  738.                 {
  739.                     hexnum2scrn(j,4,WORDRES);           // Send LF char if word results enabled
  740.                 }
  741.                 else
  742.                 {
  743.                     decnum2scrn(j,5,WORDRES);           // Send LF char if word results enabled
  744.                 }
  745.                 break;
  746.             }
  747.             else
  748.             {
  749.                 return (ERROR);
  750.             }
  751.         case 'R': case 'r':
  752.             reset_cbus();               // Perform CMX868 General Reset and clear device write shadow registers
  753.             break;
  754.         default:
  755.             return (ERROR);
  756.     }
  757.     return (OK);                        // Return OK to indicate success
  758. }
  760. unsigned long ascregtolong(void)
  761. {
  762.     unsigned char tempbuf[6];
  764.     unsigned long tempnum=0;
  766.     unsigned long j=1;
  768.     signed char i,k;
  770.     i=0;
  772.     // Loop while characters are decimal digits  
  773.     // and are no more than 5 digits long i.e. 65535
  775.     while ((ATBUF[ATBUFPTR] <= '9') && (ATBUF[ATBUFPTR] >= '0') && (i < 6))
  776.     {
  777.         tempbuf[i++] = ATBUF[ATBUFPTR++];
  778.     }
  780.     ATBUFPTR--;
  782.     i--;
  784.     for (k=i;k>=0;k--)
  785.     {
  786.         tempnum += (tempbuf[k] - 0x30) * j;
  787.         j *= 10;
  788.     }
  790.     return (tempnum);
  791. }