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

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

Modem编程

开发平台：

Visual C++

hndshake.c：源码内容
  1. //---------------------------------------------------------------------------------------------------
  2. //  Project:-   DE8681
  3. //  Filename:-  HNDSHAKE.C
  4. //  Description:-   Handshaking Routines for CMX868.
  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 HNDSHAKE_C
  26. #include    "ef8681.h"
  28. void hndshake_init()
  29. {
  30.     reset_cbus();   // Reset the CBUS before we start, will clear all shadow write registers
  31.     pwrup();        // Power Up CMX868 with correct Xtal and fixed equalisers initially enabled.
  33.     CMXTXMODE ^= (((int) S25) << 9) & 0x0E00;   // Extract required Tx level from S25.
  34.     wr16_cbus(CMXTXMODE_ADDR, CMXTXMODE);       // Update CBUS register
  36.     CMXRXMODE ^= (((int) S26) << 9) & 0x0E00;   // Extract required Rx level from S26.
  37.     wr16_cbus(CMXRXMODE_ADDR, CMXRXMODE);       // Update CBUS register
  39.     FIX_EQU = USER_FIX_EQU;                     // Extract required Tx and Rx Fixed Equaliser settings from S24.
  40.     wr16_cbus(CMXGENCTRL_ADDR, CMXGENCTRL);     // Update CBUS register
  41. }
  43. unsigned char hndshake_go()
  44. {
  45.     unsigned char   tmpresult;
  47.     if (ANSORIG)        // Check S14 Bit 7, if set we are originating a call
  48.     {
  49.         GPT6 = S7;      // Load GPT6 (1s) with Wait for carrier after dial S-Register
  51.         switch(S27 & 0b11110000)
  52.         {
  53.             case PROTB0: case PROTB1:
  54.                 tmpresult = orig_V22bis();
  55.                 break;
  56.             case PROTB2:
  57.                 tmpresult = orig_V23();
  58.                 break;
  59.             case PROTB3:
  60.                 tmpresult = orig_V23r();
  61.                 break;
  62.             case PROTB4:
  63.                 tmpresult = orig_V22_600();
  64.                 break;
  65.             case PROTB5:
  66.                 tmpresult = orig_V21();
  67.                 break;
  68.             case PROTB6:
  69.                 tmpresult = orig_212a();
  70.                 break;
  71.             case PROTB7:
  72.                 tmpresult = orig_202();
  73.                 break;
  74.             case PROTB8:
  75.                 tmpresult = orig_202r();
  76.                 break;
  77.             case PROTB9:
  78.                 tmpresult = orig_103();
  79.                 break;
  80.             default:
  81.                 return(ERROR);          // Indicate Error has occured 
  82.         }
  83.     }
  84.     else
  85.     {
  86.         GPT6 = S18;                 // Load GPT6 (1s) with General Purpose timer setting
  88.         switch(S27 & 0b11110000)
  89.         {
  90.             case PROTB0: case PROTB1:
  91.                 ans_tone();
  92.                 tmpresult = ans_V22bis();
  93.                 break;
  94.             case PROTB2:
  95.                 ans_tone();
  96.                 tmpresult = ans_V23();
  97.                 break;
  98.             case PROTB3:
  99.                 ans_tone();
  100.                 tmpresult = ans_V23r();
  101.                 break;
  102.             case PROTB4:
  103.                 ans_tone();
  104.                 tmpresult = ans_V22_600();
  105.                 break;
  106.             case PROTB5:
  107.                 ans_tone();
  108.                 tmpresult = ans_V21();
  109.                 break;
  110.             case PROTB6:
  111.                 tmpresult = ans_212a();
  112.                 break;
  113.             case PROTB7:
  114.                 tmpresult = ans_202();
  115.                 break;
  116.             case PROTB8:
  117.                 tmpresult = ans_202r();
  118.                 break;
  119.             case PROTB9:
  120.                 tmpresult = ans_103();
  121.                 break;
  122.             default:
  123.                 return(ERROR);          // Indicate Error has occured
  124.         }
  125.     }
  126.     if ((tmpresult != NYI) && (tmpresult != NOCARRIER))
  127.     {
  128.         DATAXFER = 1;
  129.         ATCMDMODE = 0;
  131.         switch(S22 & 0b11100000)
  132.         {
  133.             case X0CALLING:
  134.                 return(CONNECT);
  135.             default:
  136.                 return(tmpresult);
  137.         }
  138.     }
  139.     else
  140.     {
  141.         return(tmpresult);  
  142.     }
  143. }
  145. unsigned char orig_V22bis()
  146. {
  147.     unsigned char det32ones = 0;
  148.     unsigned char tx2400flag = 0;
  149.     unsigned char gotS1pattern = 0;
  151. // Stage 1 Look for unscrambled 1's or 2225Hz tone
  152.     CMXRXMODE &= 0x0E00;                    // Mask Rx Gain settings 
  153.     CMXRXMODE ^= 0x1002;                    // Setup Rx for 2225Hz Answer Tone Detection (will detect unscram 1's)
  154.     wr16_cbus(CMXRXMODE_ADDR, CMXRXMODE);   // Update Rx Mode CBUS register
  156.     GPT1 = 12;                      // Start 150ms timer (Answer Tone detector has approx 30ms response time)
  158.     do {
  159.         DelayMs(5);                 // Insert 5ms polling delay 
  160.         if (KEYABORT || (GPT6 == 0))
  161.         {                           // Return No Carrier message if key pushed or
  162.             return(NOCARRIER);      // if wait carrier after dial timer has expired
  163.         }
  164.         CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  165.         if (!ANS2225DET)                    // If 2225Hz Answer Tone is not detected
  166.         {
  167.             GPT1 = 12;                  // Restart 2225Hz Answer Tone detect timer
  168.         }
  169.     } while(GPT1 != 0);                 // Continue to loop until unscram 1's detected for approx 150ms
  171. // Stage 2 Wait for 450ms
  172.     CMXRXMODE &= 0x0E00;                // Mask Rx Gain settings 
  173.     CMXRXMODE ^= 0xD0F8;                // Setup Rx for high band V.22 1200bps, auto-equaliser disabled,
  174.                                         // Descrambler enabled and synchronous operation
  175.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  177.     GPT1 = 45;                          // Start 450ms timer
  179.     do {
  180.         if (KEYABORT || (GPT6 == 0))
  181.         {                               // Return No Carrier message if key pushed or
  182.             return(NOCARRIER);          // if wait carrier after dial timer has expired
  183.         }
  184.     } while (GPT1 != 0);
  186. // Stage 3 Tx S1 Pattern if V22bis selected
  187.     if ((S27 & 0b11110000) == PROTB0) 
  188.     {
  189.         CMXTXMODE &= 0x0E00;    // Mask Tx Gain settings 
  190.         CMXTXMODE ^= 0xC018;    // Initially setup Tx for low band V.22 1200bps, no guard tone
  191.                                 // No Guard tone, scrambler Disabled, synchronous operation and Tx S1 pattern
  192.         wr16_cbus(CMXTXMODE_ADDR, CMXTXMODE);       // Update Tx Mode CBUS register
  194.         GPT1 = 10;              // Start 100ms timer
  195.         do {
  196.             if (KEYABORT || (GPT6 == 0))
  197.             {                       // Return No Carrier message if key pushed or
  198.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  199.             }
  200.         } while(GPT1 !=0);          // Wait for 100ms timer to expire
  201.     }
  203. // Stage 4 Tx 1200bps scrambled 1's
  204.     CMXTXDATA = 0xFF;
  205.     wr_cbus(CMXTXDATA_ADDR, CMXTXDATA); // Ensure Tx data reg is all 1's
  207.     CMXTXMODE &= 0x0E00;    // Mask Tx gain settings
  208.     CMXTXMODE ^= 0xC07F;    // Setup Tx for low band V.22 1200bps, no guard tone
  209.                             // Scrambler enabled, sync operation and Tx data byte reg
  210.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  212. // Stage 5 Look for S1 pattern if V22bis selected
  213.     if ((S27 & 0b11110000) == PROTB0)
  214.     {
  215.         GPT1 = 27;                  // Start 270ms timer
  217.         do {
  218.             DelayMs(5);             // Insert 5ms polling delay 
  219.             if (KEYABORT || (GPT6 == 0))
  220.             {                       // Return No Carrier message if key pushed or
  221.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  222.             }
  223.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  224.             if (RXENERGYDET && S1DET)
  225.             {
  226.                 gotS1pattern = 1;   // Set flag to indicate S1 pattern was found
  227.             }
  228.         } while((GPT1 != 0) && !gotS1pattern);  // Continue to loop until timer expires or S1 pattern is detected
  229.     }
  231.     if (gotS1pattern)
  232.     {
  233. // Stage 6 If the S1 pattern was detected wait until it goes away 
  234.         do {
  235.             DelayMs(5);             // Insert 5ms polling delay 
  236.             if (KEYABORT || (GPT6 == 0))
  237.             {                       // Return No Carrier message if key pushed or
  238.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  239.             }
  240.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  241.         } while(S1DET);             // Wait until S1 Pattern has gone
  242. // Stage 7
  243.         GPT1 = 60;                  // Start 600ms timer
  245.         do {
  246.             if (KEYABORT || (GPT6 == 0))
  247.             {                       // Return No Carrier message if key pushed or
  248.                 return(NOCARRIER);  // if general purpose timer (S18) has expired
  249.             }
  250.         } while (GPT1 >= 30);       // Wait until 300ms has expired
  252.         AUTO_EQU = 1;               // Enable Rx Auto-Equaliser for training (must be enabled for 2400bps operation)
  253.         wr16_cbus(CMXRXMODE_ADDR, CMXRXMODE);       // Update Rx Mode CBUS register 
  255.         do {
  256.             if (KEYABORT || (GPT6 == 0))
  257.             {                       // Return No Carrier message if key pushed or
  258.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  259.             }
  260.         } while (GPT1 >= 15);       // Wait until 450ms has expired
  262. // Stage 8 Switch Rx Mode to 2400bps (Detectors and associated status flags will be reset)
  263.         CMXRXMODE &= 0x0FFF;        // Unmask Rx Mode bit settings
  264.         CMXRXMODE ^= 0xF000;        // Setup Rx for high band V.22bis 2400bps
  265.         wr16_cbus(CMXRXMODE_ADDR, CMXRXMODE);       // Update Rx Mode CBUS register
  267. // Stage 9 Wait until 32 continuous 1's are detected and transmitter has switched to 2400bps scram 1's
  268.         do {
  269.             DelayMs(5);             // Insert 5ms polling delay 
  270.             if (KEYABORT || (GPT6 == 0))
  271.             {                       // Return No Carrier message if key pushed or
  272.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  273.             }
  274.             if (!tx2400flag)
  275.             {
  276.                 if (GPT1 == 0)      // Check if 600ms timer has expired
  277.                 {
  278.                     CMXTXMODE &= 0x0FFF;    // Unmask Tx Mode bit settings
  279.                     CMXTXMODE ^= 0xE000;    // Setup Tx for low band V.22 bis 2400bps
  280.                     wr16_cbus(CMXTXMODE_ADDR, CMXTXMODE);   // Update Tx Mode CBUS register 
  282.                     GPT1 = 20;      // Load 200ms Timer
  283.                     tx2400flag = 1;
  284.                 }
  285.             }
  286.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  288.             if (RXENERGYDET && CONTA && CONTB && !det32ones)
  289.             {
  290.                 DCDN = 0;           // Clear DCDN line.
  291.                 DCDIND = 1;         // Turn on CD LED.
  292.                 det32ones = 1;      // Set detect 32 1's flag
  293.             }
  294.         } while(!RXENERGYDET || !CONTA || !CONTB || !tx2400flag);   // Wait until 2400bps cont 1's is detected and
  295.                                     // 2400bps has started transmitting
  296. // Stage 10 Ensure final 200ms timer has expired
  297.         do {
  298.             if (KEYABORT || (GPT6 == 0))
  299.             {                       // Return No Carrier message if key pushed or
  300.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  301.             }
  302.         } while (GPT1 != 0);        // Ensure 200ms timer has expired
  303.     }
  304.     else
  305.     {
  306.         if (((S27 & 0b11110000) == PROTB0) && !FALLBACK)
  307.         {
  308.             return(NOCARRIER);      // Return No Carrier message
  309.         }
  311. // Stage 11 Detect scrambled 1's for 270ms
  312.         GPT1 = 24;                  // Start 270ms timer (scram 1's detect has approx 30ms (32 bits) response time)
  314.         do {
  315.             DelayMs(5);             // Insert 5ms polling delay 
  316.             if (KEYABORT || (GPT6 == 0))
  317.             {                       // Return No Carrier message if key pushed or
  318.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  319.             }
  320.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);      // Read status register and update shadow register
  321.             if (!RXENERGYDET || !CONTA || !CONTB)   // If rx energy or scram 1's are not detected
  322.             {
  323.                 GPT1 = 24;          // Restart scram 1's detect timer
  324.             }
  325.         } while(GPT1 != 0);         // Continue to loop until scram 1's detected for approx 270ms
  327.         AUTO_EQU = USER_AUTO_EQU;   // Extract Auto Equaliser setting from S24.
  328.         wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);        // Update Rx Mode CBUS register 
  330.         DCDN = 0;                   // Clear DCDN line.
  331.         DCDIND = 1;                 // Turn on CD LED.
  333. // Stage 12 Start 770ms timer
  334.         GPT1 = 77;
  335.         do {
  336.             if (KEYABORT || (GPT6 == 0))
  337.             {                       // Return No Carrier message if key pushed or
  338.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  339.             }
  340.         } while (GPT1 != 0);        // Wait until 770ms has expired
  341.     }
  342. // Stage 13
  343.     async_setup();                  // Configure Tx/Rx for async operation (settings extracted from S25 and S26)
  345.     if (!gotS1pattern)
  346.     {
  347.         return(CON1200);            // Return Connect 1200
  348.     }
  349.     else
  350.     {
  351.         return(CON2400);            // Return Connect 2400
  352.     }
  353. }
  355. unsigned char orig_V23()
  356. {
  357. // Stage 1
  358.     CMXRXMODE &= 0x0E00;    // Mask Rx Gain settings
  359.     CMXRXMODE ^= 0x5038;    // Setup Rx for V23 1200bps and auto-equaliser disabled
  360.                             // Descrambler Disabled, synchronous operation
  361.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  363.     if (unscram1sdet(12) != OK) return(NOCARRIER);  // Detect unscram 1's for 150ms (1's detect has approx 30ms (32bits) response time)
  365. // Stage 2
  366.     DCDN = 0;       // Clear DCDN line.
  367.     DCDIND = 1;     // Turn on CD LED.
  369.     GPT1 = 77;      // Start 770ms timer
  371.     do {
  372.         if (KEYABORT || (GPT6 == 0))
  373.         {                       // Return No Carrier message if key pushed or
  374.             return(NOCARRIER);  // if wait carrier after dial timer has expired
  375.         }
  376.     } while (GPT1 >= 32);       // Wait until 450ms has expired
  378. // Stage 3
  379.     CMXTXDATA = 0xFF;
  380.     wr_cbus(CMXTXDATA_ADDR,CMXTXDATA);  // Ensure Tx data reg is all 1's
  382.     CMXTXMODE &= 0x0E00;    // Mask Tx Gain Settings
  383.     CMXTXMODE ^= 0x401F;    // Setup Tx for V23 75bps, no guard tone
  384.                             // No Guard tone, scram disabled, sync operation, Tx data byte reg
  385.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  386. // Stage 4
  387.     do {
  388.         if (KEYABORT || (GPT6 == 0))
  389.         {                       // Return No Carrier message if key pushed or
  390.             return(NOCARRIER);  // if wait carrier after dial timer has expired
  391.         }
  392.     } while (GPT1 != 0);        // Ensure 770ms timer has expired
  394. // Stage 5
  395.     async_setup();              // Configure Tx/Rx for async operation (settings extracted from S25 and S26)
  397.     return(CON751200);          // Return Connect 75/1200
  398. }
  400. unsigned char orig_V23r()
  401. {
  402.     return(NYI);
  403. }
  405. unsigned char orig_V22_600()
  406. {
  407.     return(NYI);
  408. }
  410. unsigned char orig_V21()
  411. {
  412.     return(NYI);
  413. }
  415. unsigned char orig_212a()
  416. {
  417.     return(NYI);
  418. }
  420. unsigned char orig_202()
  421. {
  422.     return(NYI);
  423. }
  425. unsigned char orig_202r()
  426. {
  427.     return(NYI);
  428. }
  430. unsigned char orig_103()
  431. {
  432. // Stage 1
  433.     CMXRXMODE &= 0x0E00;    // Mask Rx Gain settings
  434.     CMXRXMODE ^= 0x7038;    // Setup Rx for high band Bell 103 300bps and auto-equaliser disabled
  435.                             // Descrambler Disabled and synchronous operation
  436.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  438.     if (unscram1sdet(5) != OK) return(NOCARRIER);   // Detect unscram 1's for 150ms (1's detect has approx 100ms (32bits) response time)
  440. // Stage 2
  441.     DCDN = 0;               // Clear DCDN line.
  442.     DCDIND = 1;             // Turn on CD LED.
  444.     GPT1 = 77;              // Start 770ms timer
  446.     do {
  447.         if (KEYABORT || (GPT6 == 0))
  448.         {                       // Return No Carrier message if key pushed or
  449.             return(NOCARRIER);  // if wait carrier after dial timer has expired
  450.         }
  451.     } while (GPT1 >= 32);       // Wait until 450ms has expired
  453. // Stage 3
  454.     CMXTXDATA = 0xFF;
  455.     wr_cbus(CMXTXDATA_ADDR,CMXTXDATA);  // Ensure Tx data reg is all 1's
  457.     CMXTXMODE &= 0x0E00;    // Mask Tx Gain settings
  458.     CMXTXMODE ^= 0x601F;    // Setup Tx for low band Bell 103 300bps, no guard tone
  459.                             // No Guard tone, scram disabled, sync operation, Tx data byte reg
  460.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  461. // Stage 4
  462.     do {
  463.         if (KEYABORT || (GPT6 == 0))
  464.         {                       // Return No Carrier message if key pushed or
  465.             return(NOCARRIER);  // if wait carrier after dial timer has expired
  466.         }
  467.     } while (GPT1 != 0);        // Ensure 770ms timer has expired
  469. // Stage 5
  470.     async_setup();              // Configure Tx/Rx for async operation (settings extracted from S25 and S26)
  472.     return(CON300);             // Return Connect 300
  473. }
  475. void ans_tone()
  476. {
  477. // Stage 1 Tx No Tone for 2.2s
  478.     CMXTXMODE &= 0x0E00;    // Mask Tx Gain settings
  479.     CMXTXMODE ^= 0x1000;    // Initially setup Tx for tones, no guard tone
  480.                             // No Guard tone, scrambler Disabled, fixed tone, no tone
  481.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  483.     GPT3 = 22;              // Start 2.2s timer
  484.     while(GPT3 != 0)
  485.         continue;
  487. // Stage 2 Tx 2100Hz for 3.3s
  488.     CMXTXMODE ^= 0x000A;    // No Guard tone, scrambler Disabled, fixed tone, 2100Hz
  489.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  491.     GPT3 = 33;              // Start 3.3s timer
  492.     while(GPT3 != 0)
  493.         continue;
  495. // Stage 3 Tx No Tone for 80ms
  496.     CMXTXMODE &= 0xFF00;    // No Guard tone, scrambler Disabled, fixed tone, no tone
  497.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  499.     GPT1 = 8;               // Start 80ms timer
  500.     while(GPT1 != 0)
  501.         continue;
  502. }
  504. unsigned char ans_V22bis()
  505. {
  506.     unsigned char det32ones = 0;
  507.     unsigned char tx2400flag = 0;
  508.     unsigned char gotS1pattern = 0;
  510. // Stage 1 Tx unscrambled 1's
  511.     CMXRXMODE &= 0x0E00;    // Mask Rx Gain settings
  512.     CMXRXMODE ^= 0xC0F8;    // Setup Rx for low band V.22 1200bps and auto-equaliser disabled
  513.                             // Descrambler enabled, synchronous operation
  514.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  516.     CMXTXDATA = 0xFF;
  517.     wr_cbus(CMXTXDATA_ADDR,CMXTXDATA);  // Ensure Tx data reg is all 1's
  519.     CMXTXMODE &= 0x0E00;                    // Mask Tx Gain settings
  520.     CMXTXMODE ^= (((int) S23) << 1) & 0x0180;   // Extract Guard Tone setting from S23.
  521.     CMXTXMODE ^= 0xD01F;                        // Initially setup Tx for high band V.22 1200bps
  522.                                 // Scrambler Disabled, sync and Tx data byte
  523.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);        // Update CBUS register
  525. // Stage 2 Look for scrambled 1's and also S1 pattern if V22bis selected
  526.     GPT1 = 24;                      // Start 270ms timer (scram 1's detect has approx 30ms (32 bits) response time)
  527.     do {
  528.         DelayMs(5);                 // Insert 5ms polling delay 
  529.         if (KEYABORT || (GPT6 == 0))
  530.         {                           // Return No Carrier message if key pushed or
  531.             return(NOCARRIER);      // if general purpose timer (S18) has expired
  532.         }
  533.         CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  535.         if (!RXENERGYDET || !CONTA || !CONTB)   // If rx energy or scram 1's are not detected
  536.         {
  537.             GPT1 = 24;              // Restart scram 1's detect timer
  538.         }
  540.         if ((S27 & 0b11110000) == PROTB0)   // Look for S1 Pattern if V22bis was selected 
  541.         {
  542.             if (!FALLBACK)          // If modulation fallback is not enabled 
  543.             {                       // prevent detection of V22 handshaking sequence
  544.                 GPT1 = 24;          // by restarting scram 1's detect timer
  545.             }
  546.             if (RXENERGYDET && S1DET)
  547.             {
  548.                 gotS1pattern = 1;   // Set flag to indicate S1 pattern was found
  549.             }
  550.         }
  551.     } while(GPT1 != 0 && !gotS1pattern);    // Continue to loop until scram 1's detected for approx 270ms
  553.     if (gotS1pattern)
  554.     {
  555. // Stage 3 If the S1 pattern was detected wait until it goes away
  556.         do {                        // Wait until end of S1 pattern
  557.             DelayMs(5);             // Insert 5ms polling delay 
  558.             if (KEYABORT || (GPT6 == 0))
  559.             {                       // Return No Carrier message if key pushed or
  560.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  561.             }
  562.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  563.         } while(S1DET);             // Wait until S1 Pattern has gone
  565. // Stage 4 Tx S1 pattern for 100ms
  566.         CMXTXMODE &= 0xFFF8;        // Now Tx S1 pattern
  567.         wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  569.         GPT1 = 60;                  // Start 600ms timer
  570.         do {
  571.             if (KEYABORT || (GPT6 == 0))
  572.             {                       // Return No Carrier message if key pushed or
  573.                 return(NOCARRIER);  // if general purpose timer (S18) has expired
  574.             }
  575.         } while(GPT1 >= 50);        // Wait for 100ms timer to expire
  577. // Stage 5 Tx scrambled 1's
  578.         CMXTXMODE &= 0xFF98;    // Unmask scrambler and Tx Data source bit settings
  579.         CMXTXMODE ^= 0x0067;    // Scrambler enabled and Tx data byte
  580.         wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  582. // Stage 6 Wait for 300ms timer to expire before enabling Rx Auto-Equaliser (will ensure it is receiving randomised data)
  583.         do {
  584.             if (KEYABORT || (GPT6 == 0))
  585.             {                       // Return No Carrier message if key pushed or
  586.                 return(NOCARRIER);  // if general purpose timer (S18) has expired
  587.             }
  588.         } while (GPT1 >= 30);       // Wait until 300ms has expired
  590.         AUTO_EQU = 1;               // Enable Rx Auto-Equaliser for training (must be enabled for 2400bps operation)
  591.         wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  593. // Stage 7 wait for 450ms timer to expire
  594.         do {
  595.             if (KEYABORT || (GPT6 == 0))
  596.             {                       // Return No Carrier message if key pushed or
  597.                 return(NOCARRIER);  // if general purpose timer (S18) has expired
  598.             }
  599.         } while (GPT1 >= 15);       // Wait until 450ms has expired
  601. // Stage 8 Switch Rx Mode to 2400bps (Detectors and associated status flags will be reset)
  602.         CMXRXMODE &= 0x0FFF;    // Unmask Rx Mode bit settings
  603.         CMXRXMODE ^= 0xE000;    // Setup Rx for low band V.22bis 2400bps
  604.         wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  606. // Stage 9 Wait until 32 continuous scram 1's at 2400bps are detected and the transmitter has switched to 2400bps scram 1's
  607.         do {
  608.             DelayMs(5); // Insert 5ms polling delay 
  609.             if (KEYABORT || (GPT6 == 0))
  610.             {                       // Return No Carrier message if key pushed or
  611.                 return(NOCARRIER);  // if wait carrier after dial timer has expired
  612.             }
  613.             if (!tx2400flag)
  614.             {
  615.                 if (GPT1 == 0)      // Check if 600ms timer has expired
  616.                 {
  617.                     CMXTXMODE &= 0x0FFF;    // Unmask Tx Mode bit settings
  618.                     CMXTXMODE ^= 0xF000;    // Setup Tx for high band V.22 bis 2400bps
  619.                     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register 
  621.                     GPT1 = 20;              // Load 200ms Timer
  622.                     tx2400flag = 1;
  623.                 }
  624.             }
  625.             CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  627.             if (RXENERGYDET && CONTA && CONTB && !det32ones)
  628.             {
  629.                 DCDN = 0;           // Clear DCDN line.
  630.                 DCDIND = 1;         // Turn on CD LED.
  631.                 det32ones = 1;      // Set detect 32 1's flag
  632.             }
  633.         } while(!RXENERGYDET || !CONTA || !CONTB || !tx2400flag);   // Wait until 2400bps cont 1's is detected and
  634.                                     // 2400bps has started transmitting
  635. // Stage 10 Ensure final 200ms timer has expired
  636.         do {
  637.             if (KEYABORT || (GPT6 == 0))
  638.             {                       // Return No Carrier message if key pushed or
  639.                 return(NOCARRIER);  // if general purpose timer (S18) has expired
  640.             }
  641.         } while (GPT1 != 0);        // Ensure 200ms timer has expired
  642.     }
  643.     else
  644.     {
  645. // Stage 11 Tx scrambled 1's
  646.         CMXTXMODE &= 0xFF9F;        // Unmask scrambler bit settings
  647.         CMXTXMODE ^= 0x0060;        // Enable scrambler
  648.         wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update Tx Mode CBUS register
  650.         AUTO_EQU = USER_AUTO_EQU;   // Extract Auto Equaliser setting from S24.
  651.         wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  653. // Stage 12 Wait for 770ms timer to expire
  654.         GPT1 = 77;                  // Start 770ms timer
  655.         do {
  656.             if (KEYABORT || (GPT6 == 0))
  657.             {                       // Return No Carrier message if key pushed or
  658.                 return(NOCARRIER);  // if general purpose timer (S18) has expired
  659.             }
  660.         } while (GPT1 != 0);        // Wait until 770ms has expired
  662.         DCDN = 0;                   // Clear DCDN line.
  663.         DCDIND = 1;                 // Turn on CD LED.
  664.     }
  665. // Stage 13
  666.     async_setup();                  // Configure Tx/Rx for async operation (settings extracted from S25 and S26)
  668.     if (!gotS1pattern)
  669.     {
  670.         return(CON1200);            // Return Connect 1200
  671.     }
  672.     else
  673.     {
  674.         return(CON2400);            // Return Connect 2400
  675.     }
  676. }
  678. unsigned char ans_V23()
  679. {
  680. // Stage 1 Tx unscrambled cont 1's
  681.     CMXRXMODE &= 0x0E00;            // Mask Rx Gain settings
  682.     CMXRXMODE ^= 0x4038;            // Setup Rx for V23 75bps and auto-equaliser disabled
  683.                                     // Descrambler disabled, synchronous operation
  684.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  686.     CMXTXDATA = 0xFF;
  687.     wr_cbus(CMXTXDATA_ADDR,CMXTXDATA);      // Ensure Tx data reg is all 1's
  689.     CMXTXMODE &= 0x0E00;    // Mask Tx Gain settings
  690.     CMXTXMODE ^= 0x501F;    // Setup Tx for V23 1200bps, no guard tones
  691.                             // Scrambler disabled, sync operation, Tx data byte
  692.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update CBUS register
  694. // Stage 2 Detect unscram 1's for 150ms (use FSK demod output for this low baud rate detection)
  695.     GPT1 = 15;              // Start timer
  696.     do {
  697.         if (KEYABORT || (GPT6 == 0))
  698.         {                       // Return No Carrier message if key pushed or
  699.             return(NOCARRIER);  // if GPT6 has expired
  700.         }
  701.         CMXSTAT = rd16_cbus(CMXSTAT_ADDR);  // Read status register and update shadow register
  702.         if (!RXENERGYDET || !FSKOUT)        // If rx energy not detected or FSK demod output low
  703.         {
  704.             GPT1 = 15;      // Restart unscram 1's detect timer
  705.         }
  706.     } while(GPT1 != 0);     // Continue to loop until unscram 1's detected for 150ms
  708. // Stage 3
  709.     async_setup();          // Configure Tx/Rx for async operation (settings extracted from S25 and S26)
  711.     DCDN = 0;               // Clear DCDN line.
  712.     DCDIND = 1;             // Turn on CD LED.
  714.     return(CON120075);      // Return Connect 1200/75
  715. }
  717. unsigned char ans_V23r()
  718. {
  719.     return(NYI);
  720. }
  722. unsigned char ans_V22_600()
  723. {
  724.     return(NYI);
  725. }
  727. unsigned char ans_V21()
  728. {
  729.     return(NYI);
  730. }
  732. unsigned char ans_212a()
  733. {
  734.     return(NYI);
  735. }
  737. unsigned char ans_202()
  738. {
  739.     return(NYI);
  740. }
  742. unsigned char ans_202r()
  743. {
  744.     return(NYI);
  745. }
  747. unsigned char ans_103()
  748. {
  749. // Stage 1 Tx unscrambled cont 1's
  750.     CMXRXMODE &= 0x0E00;    // Mask Rx Gain settings
  751.     CMXRXMODE ^= 0x6038;    // Setup Rx for low band Bell 103 300bps and auto-equaliser disabled
  752.                             // Descrambler disabled, synchronous operation
  753.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);    // Update Rx Mode CBUS register
  755.     CMXTXDATA = 0xFF;
  756.     wr_cbus(CMXTXDATA_ADDR,CMXTXDATA);    // Ensure Tx data reg is all 1's
  758.     CMXTXMODE &= 0x0E00;    // Mask Tx Gain settings
  759.     CMXTXMODE ^= 0x701F;    // Setup Tx for high band Bell 103 300bps, no guard tones
  760.                             // Scrambler disabled, sync operation and Tx data byte
  761.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);    // Update CBUS register
  763. // Stage 2
  764.     if (unscram1sdet(5) != OK) return(NOCARRIER);   // Detect unscram 1's for 150ms (1's detect has approx 100ms (32bits) response time)
  766. // Stage 3
  767.     async_setup();          // Configure Tx/Rx for async operation (settings extracted from S25 and S26)
  769.     DCDN = 0;               // Clear DCDN line.
  770.     DCDIND = 1;             // Turn on CD LED.
  772.     return(CON300);         // Return Connect 300
  773. }
  775. void async_setup()
  776. {
  777.     CMXTXMODE &= 0xFFE0;    // Unmask Tx Data format bit settings
  778.     CMXTXMODE ^= ((((int) S25) >> 3) & 0x001F); // Extract Tx Data/Stop bit and async mode settings from S25.
  779.     wr16_cbus(CMXTXMODE_ADDR,CMXTXMODE);        // Update Tx Mode CBUS register
  781.     RXUSART = 1;            // Ensure Rx USART is enabled 
  782.     CMXRXMODE &= 0xFFE0;    // Unmask Rx USART bit settings
  783.     CMXRXMODE ^= ((((int) S26) >> 3) & 0x001F); // Extract Rx Data/parity and async mode settings from S26.
  784.     wr16_cbus(CMXRXMODE_ADDR,CMXRXMODE);        // Update Rx Mode CBUS register
  785. }
  787. unsigned char unscram1sdet(unsigned char dettime)   // Uses general purpose timers GPT1 and GPT6
  788. {
  789.     GPT1 = dettime;                     // Start timer
  790.     do {
  791.         DelayMs(5);                     // Insert 5ms polling delay 
  792.         if (KEYABORT || (GPT6 == 0))
  793.         {                       // Return No Carrier message if key pushed or
  794.             return(NOCARRIER);  // if GPT6 has expired
  795.         }
  796.         CMXSTAT = rd16_cbus(CMXSTAT_ADDR);      // Read status register and update shadow register
  797.         if (!RXENERGYDET || !CONTA || CONTB)    // If rx energy or unscram 1's are not detected
  798.         {
  799.             GPT1 = dettime;             // Restart unscram 1's detect timer
  800.         }
  801.     } while(GPT1 != 0);                 // Continue to loop until unscram 1's detected for specified time
  802.     
  803.     return(OK);
  804. }