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

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

Modem编程

开发平台：

C/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. wr16_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
  803. return(OK);
  804. }