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

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

Modem编程

开发平台：

C/C++

ef8681.c：源码内容
  1. //---------------------------------------------------------------------------------------------------
  2. // Project:- DE8681
  3. //   Filename:- EF8681.C
  4. // Description:- Socket Modem Main Routine and Interrupt Service Routine.
  5. // Programmer:- D.T.F
  6. // Version:- 2.0
  7. // Created:- 28th February 2001
  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 EF8681_C
  26. #include "ef8681.h"
  28. main()
  29. {
  30. unsigned char tmpresult;
  32. init_micro(); // Initialise Micro
  33. init_ports(); // Initialise PIC Ports
  34. init_regs(); // Initialise registers
  35. init_sregs(0); // Initialise S registers with Factory 0 defaults.
  36. init_spi(); // Initialise SPI for control of CMX868 CBUS
  37. reset_cbus(); // Perform CMX868 General Reset and clear device shadow registers
  38. init_GPTs(); // Initialise General Purpose Timers
  40. sci_init(19200, SCI_EIGHT);
  42. PEIE = 1; // Enable Peripheral Interrupts
  43. GIE = 1; // Enable Global Interrupts
  44. RCIE = 1; // Unmask receiver interrupts
  46. while (DTRN) // Wait until DTRN is low, indicating PC COM port is connected
  47. continue;
  49. PORTB &= 0b11110111; // Now clear DSRN to indicate DE8681 connection to PC
  51. genmsgtopc(idmsg); // Send id message to terminal
  53. // CMX868 Rev C Check
  55. pwrup(); // Power Up CMX868 with correct Xtal and fixed equalisers initially enabled.
  57. if (dut_chksum() == ERROR)
  58. {
  59. genmsgtopc(dutrevmsg); // Send device revision error message to terminal
  60. }
  62. reset_cbus(); // Reset the CBUS, will clear all shadow write registers
  64. // Initial settings
  66. EVMODE = 1; // Set Evaluation Mode Flag
  67. ATCMDMODE = 1; // Set AT Command Mode Flag
  68. CTSN = 0; // Clear CTSN to indicate board is ready to receive characters
  70. // Main Loop code
  71. do
  72. {
  73. if(!DTRN)
  74. {
  75. DTRIND = 1; // Ensures that the DTR LED is lit when Hyper Terminal 
  76. } // is connected and disconnected
  77. else
  78. {
  79. DTRIND = 0;
  80. }
  82. if (BERTFLAG) // BERT can be performed whilst off-line or in Data transfer mode
  83. { // Carrier is not monitored during this test
  84. bert();
  85. init_GPTs(); // Initialise General Purpose Timers ready for normal use
  86. undo_bertporta(); // Re-initialise Port A for normal use (outputs to drive LEDs)
  87. }
  89. if (TESTFUNC1) // Test Function One outputs to screen the status register contents at the S19 rate
  90. {
  91. do
  92. {
  93. testfunc1(); // Execute Test Function One
  94. } while (!KEYABORT); // Loop until key pushed
  95. TESTFUNC1 = 0; // Clear Test Function flag
  96. KEYABORT = 0; // Reset key abort flag
  97. }
  99. if (ATCMDMODE && (S0 != 0)) // Check if auto answer is possible during AT command mode
  100. {
  101. ringdetection(); // Check for ring detect or validate ringing
  102. }
  104. if (LOADCHAR)
  105. {
  106. while (TXIE) // Wait until all previous characters are sent to screen
  107. continue;
  108. TXIE = 1; // Enable Tx Interrupt
  109. LOADCHAR = 0; // Clear Load character flag
  110. }
  112. if (INTERPRET)
  113. {
  114. resmsgtopc(atcmd_interpret());
  115. INTERPRET = 0;
  116. ATBUFPTR = 0x00; // Re-initialise AT Command Buffer pointer
  117. CTSN = 0; // Ensure CTSN is low to allow further characters
  118. }
  120. if (!DATAXFER && !ATCMDMODE)
  121. {
  122. hndshake_init();
  123. hook(1); // Go off-hook
  124. if (ANSORIG)
  125. {
  126. Delay1s(S6); // Temporary Blind Dialling always
  127. dial(); // Dial routine if originating
  128. }
  129. tmpresult = hndshake_go();
  130. resmsgtopc(tmpresult);
  131. if ((tmpresult == NOCARRIER) || (tmpresult == NYI))
  132. {
  133. reset_cbus(); // Reset CMX868 into powersave, will cause board to go on-hook
  134. DCDIND = 0; // Turn off CD LED
  135. DCDN = 1; // Set DCDN line
  136. DATAXFER = 0; // Abort data transfer 
  137. ATCMDMODE = 1; // Revert back to AT Command Mode
  138. KEYABORT = 0; // Ensure key abort flag is cleared
  139. }
  140. }
  142. if (DATAXFER && !ATCMDMODE)
  143. {
  144. dataxfer(); // Data Transfer loop, will exit if carrier is lost
  145. // or escape sequence is entered
  146. while (TXIE) // Ensure all outstanding rx data has been displayed before continuing 
  147. continue;
  149. CTSN = 0; // Ensure CTSN is low to allow further characters
  151. if (!DATAXFER)
  152. {
  153. resmsgtopc(NOCARRIER); // Return No Carrier message to PC
  154. }
  155. else
  156. {
  157. resmsgtopc(OK); // Return OK message to PC
  158. }
  159. }
  161. if (DATAXFER && (POLLTMR == 0))
  162. {
  163. CMXSTAT = rd16_cbus(CMXSTAT_ADDR); // Read CMX868 Status reg and update shadow reg
  164. if (hangup()) // If the carrier detect flag has been lost
  165. {
  166. reset_cbus(); // Reset CMX868 into powersave, will cause board to go on-hook
  167. DCDIND = 0; // Turn off CD LED
  168. DCDN = 1; // Set DCDN line
  169. DATAXFER = 0; // Abort data transfer 
  170. ATCMDMODE = 1; // Revert back to AT Command Mode
  171. resmsgtopc(NOCARRIER);
  172. }
  173. POLLTMR = 20; // Reload 20ms Rx Energy polling timer
  174. }
  176. } while (EVMODE);
  177. }
  179. // Response message routine using case statements
  180. // rather than array of pointers
  182. void resmsgtopc(unsigned char messnum)
  183. {
  184. char tempbuf[24];
  186. unsigned char i=0;
  188. if (RESOFF) // Check Result Codes are required
  189. {
  190. return;
  191. }
  193. if (!WORDRES) // Check if number response are required
  194. {
  195. if (HEXOP)
  196. {
  197. hexnum2scrn(messnum,2,0); // Do not send LF char
  198. }
  199. else
  200. {
  201. decnum2scrn(messnum,2,0); // Do not send LF char
  202. }
  203. return;
  204. }
  206. switch(messnum)
  207. {
  208. case 0:
  209. strcpy(tempbuf,"OK");
  210. break;
  211. case 1:
  212. strcpy(tempbuf,"CONNECT");
  213. break;
  214. case 2:
  215. strcpy(tempbuf,"RING");
  216. break;
  217. case 3:
  218. strcpy(tempbuf,"NO CARRIER");
  219. break;
  220. case 4:
  221. strcpy(tempbuf,"ERROR");
  222. break;
  223. case 5:
  224. strcpy(tempbuf,"NO DIAL TONE");
  225. break;
  226. case 6:
  227. strcpy(tempbuf,"BUSY");
  228. break;
  229. case 7:
  230. strcpy(tempbuf,"CONNECT 2400");
  231. break;
  232. case 8:
  233. strcpy(tempbuf,"CONNECT 1200");
  234. break;
  235. case 9:
  236. strcpy(tempbuf,"CONNECT 600");
  237. break;
  238. case 10:
  239. strcpy(tempbuf,"CONNECT 300");
  240. break;
  241. case 11:
  242. strcpy(tempbuf,"CONNECT 1200/75");
  243. break;
  244. case 12:
  245. strcpy(tempbuf,"CONNECT 75/1200");
  246. break;
  247. case 13:
  248. strcpy(tempbuf,"CONNECT 1200/150");
  249. break;
  250. case 14:
  251. strcpy(tempbuf,"CONNECT 150/1200");
  252. break;
  253. case 15:
  254. strcpy(tempbuf,"NYI");
  255. break;
  256. default: // i.e. no result code
  257. return;
  258. }
  260. while ( tempbuf[i] != '')
  261. {
  262. MSGBUF[MSGBUFLDPTR++] = tempbuf[i]; // Load Character into output buffer
  264. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  266. i++; // Point to next character from message
  267. }
  269. MSGBUF[MSGBUFLDPTR++] = S3; // Load Message Buffer with CR char
  271. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  273. if (WORDRES)
  274. {
  275. MSGBUF[MSGBUFLDPTR++] = S4; // Load Message Buffer with LF char
  277. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  278. }
  280. TXIE = 1; // Enable Tx Interrupt
  281. while (TXIE)
  282. continue; // Wait until all characters have been sent to terminal
  283. }
  285. void genmsgtopc(unsigned char messnum)
  286. {
  287. char tempbuf[24];
  289. unsigned char i=0;
  291. if (RESOFF) // Check Result Codes are required
  292. {
  293. return;
  294. }
  296. switch(messnum)
  297. {
  298. case 0:
  299. strcpy(tempbuf,"EF8681 V2.0"); // Change this string when code is modified
  300. break;
  301. case 1:
  302. strcpy(tempbuf,"DE8681 Demonstration Kit");
  303. break;
  304. case 2:
  305. strcpy(tempbuf,"CML UK");
  306. break;
  307. case 3:
  308. strcpy(tempbuf,"CML Singapore");
  309. break;
  310. case 4:
  311. strcpy(tempbuf,"MX-COM, INC");
  312. break;
  313. case 5:
  314. strcpy(tempbuf,"sales@cmlmicro.co.uk");
  315. break;
  316. case 6:
  317. strcpy(tempbuf,"sales@cmlmicro.com.sg");
  318. break;
  319. case 7:
  320. strcpy(tempbuf,"mxsales@mxcom.com");
  321. break;
  322. case 8:
  323. strcpy(tempbuf,"Tel:+44(0)1621 875500");
  324. break;
  325. case 9:
  326. strcpy(tempbuf,"www.cmlmicro.co.uk");
  327. break;
  328. case 10:
  329. strcpy(tempbuf,"Invalid CMX868 Rev C");
  330. break;
  331. default:
  332. return;
  333. }
  335. while ( tempbuf[i] != '')
  336. {
  337. MSGBUF[MSGBUFLDPTR++] = tempbuf[i]; // Load Character into output buffer
  339. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  341. i++; // Point to next character from message
  342. }
  344. MSGBUF[MSGBUFLDPTR++] = S3; // Load Message Buffer with CR char
  346. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  348. if (WORDRES)
  349. {
  350. MSGBUF[MSGBUFLDPTR++] = S4; // Load Message Buffer with LF char
  352. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  353. }
  355. TXIE = 1; // Enable Tx Interrupt
  356. while (TXIE)
  357. continue; // Wait until all characters have been sent to terminal
  358. }
  360. void interrupt isr(void)
  361. {
  362. unsigned char i;
  364. if (T0IE && T0IF) // Check if Timer Interrupt Enabled and interrupt flag set
  365. {
  366. if (!BERTFLAG)
  367. {
  368. update_GPTs();
  369. }
  370. else
  371. {
  372. if (BERTEND)
  373. {
  374. bert_txd();
  375. }
  376. else
  377. {
  378. bert_rxd();
  379. }
  380. }
  381. }
  382. if (RCIE && RCIF) // Check if Rx Character Interrupt Enable and Flag
  383. {
  384. TXDIND = 1; // Turn on TXD LED
  385. GPT4 = 2; // LED will stay illuminated for approx. 200mS
  387. if (DATAXFER && !ATCMDMODE)
  388. {
  389. rx_datachars();
  390. }
  391. else
  392. {
  393. rx_atchars();
  394. }  
  395. }
  396. if (TXIE) // Check if Tx Character Interrupt is enabled
  397. {
  398. RXDIND = 1; // Turn on RXD LED
  399. GPT4=2;
  400. tx_chars();
  401. }
  402. }
  404. void init_GPTs()
  405. {
  406. ESCTMR = 0; // 50ms Escape Sequence Timer
  407. POLLTMR = 0; // 1ms General Purpose Polling Timer
  408. RDTIMEOUT = 0; // Ensure ring detect timeout reg is clear at start
  409. GPT1 = 0; // 10ms General Purpose Timers
  410. GPT2 = 0;
  411. GPT3 = 0; // 100ms General Purpose Timers
  412. GPT4 = 0;
  413. GPT5 = 0; // 1 second General Purpose Timers
  414. GPT6 = 0;
  416. PS10ms = 10; // Initialise Prescalers
  417. PS100ms = 10;
  418. PS1s = 10;
  419. ESCPS = 50;
  421. T0CS = 0; // Timer increments on instruction clock
  422. PSA=0; // Assign Prescaler to TMR0
  423. PS2=0; // Prescaler 1:4 TMR0
  424. PS1=0;
  425. PS0=1;
  426. TMR0 = 22; // Ideally TMR0 count should be 250 except
  427. // need to account for interrupt saving code
  428. // which is approximately 70us.
  429. T0IF = 0; // Clear the interrupt flag
  430. T0IE = 1; // Enable interrupt on TMR0 overflow
  431. }
  433. void update_GPTs()
  434. {
  435. T0IE = 0; // Disable Timer interrupt
  437. ESCPS--; // Decrement Escape sequence prescaler
  439. if (POLLTMR != 0) // Check status of General Purpose Polling Timer (1ms)
  440. {
  441. POLLTMR--; // Decrement General Purpose Polling Timer
  442. }
  444. if (ESCPS == 0)
  445. {
  446. ESCPS = 50; // Reload 50ms prescaler
  448. if (ESCTMR != 0) // Check status of Escape Sequence Timer (50ms)
  449. {
  450. ESCTMR--; // Decrement Escape Sequence Timer
  451. }
  452. }
  454. PS10ms--; // Decrement 10ms prescaler
  456. if (PS10ms == 0)
  457. {
  458. PS10ms = 10; // Reload 10ms prescaler
  460. PS100ms--; // Decrement 100ms Prescaler
  462. if (GPT1 != 0) // Check status of General Purpose Timer 1 (10ms)
  463. {
  464. GPT1--; // Decrement General Purpose Timer 1
  465. }
  467. if (GPT2 != 0) // Check status of General Purpose Timer 2 (10ms)
  468. {
  469. GPT2--; // Decrement General Purpose Timer 2
  470. }
  472. if (PS100ms == 0)
  473. {
  474. PS100ms = 10; // Reload 100ms prescaler
  476. PS1s--; // Decrement 1s Prescaler
  478. if (CDLOSTTMR != 0) // Check status of Carrier Detect Lost Timer (100ms)
  479. {
  480. CDLOSTTMR--; // Decrement Carrier Detect Lost Timer
  481. }
  483. if (RDTIMEOUT != 0) // Check status of Ring Detect timeout reg (100ms)
  484. {
  485. RDTIMEOUT--; // Decrement Ring Detect timeout reg
  486. }
  488. if (GPT3 != 0) // Check status of General Purpose Timer 3 (100ms)
  489. {
  490. GPT3--; // Decrement General Purpose Timer 3
  491. }
  493. if (GPT4 != 0) // Check status of General Purpose Timer 4 (100ms)
  494. {
  495. GPT4--; // Decrement General Purpose Timer 4
  496. }
  497. else
  498. {
  499. if(LED_OVERRIDE)
  500. {
  501. // Ensures that the TXD and RXD LEDs stay illuminated
  502. TXDIND = 1; // after an at@f1 command
  503. RXDIND = 1;
  504. }
  505. if(!LED_OVERRIDE)
  506. {
  507. TXDIND = 0; // Ensures that the TXD and RXD LEDs 
  508. RXDIND = 0;
  509. }
  510. }
  512. if (PS1s == 0)
  513. {
  514. PS1s = 10; // Reload 1s prescaler
  516. if (GPT5 != 0) // Check status of General Purpose Timer 5 (1s)
  517. {
  518. GPT5--; // Decrement General Purpose Timer 5
  519. }
  521. if (GPT6 != 0) // Check status of General Purpose Timer 6 (1s)
  522. {
  523. GPT6--; // Decrement General Purpose Timer 6
  524. }
  525. }
  526. }
  527. }
  529. TMR0 = 22; // Reload the timer (250us * 4) per interrupt
  530. // Delay in interrupt saving adjusted for
  531. T0IF = 0; // Clear the interrupt flag
  533. T0IE = 1; // Enable Timer interrupt
  534. }
  536. void init_regs()
  537. {
  538. unsigned char i;
  540. for(i=0; i<48; i++)
  541. {
  542. ATBUF[i] = 0; // Clear AT Command Buffer 
  543. }
  545. for(i=0; i<32; i++)
  546. {
  547. MSGBUF[i] = 0; // Clear Message Buffer 
  548. }
  550. TELNUM[0] = NUL; // Will intially appear empty
  552. MODEMSTAT = 0x00; // Initially set Evaluation Mode Flag and AT Command Mode Flag
  553. ATCMDSTAT = 0x00; // Clear AT Command Status register
  554. BERTSTAT = 0x00;
  555. XFERSTAT = 0x00;
  558. ATBUFPTR = 0x00; // Initialise AT Command Buffer pointer
  559. MSGBUFLDPTR = 0x00; // Initialise Message Buffer Load pointer
  560. MSGBUFRDPTR = 0x00; // Initialise Message Buffer Read pointer
  562. DATABUFLDPTR = 0x00; // Initialise Data Buffer Load pointer
  563. DATABUFRDPTR = 0x00; // Initialise Data Buffer Read pointer
  564. }
  566. void init_sregs(unsigned char settings)
  567. {
  569. static unsigned char bank1 sreginit[2][30] ={ // Factory Profile 0
  570. { 0,0,43,13,10,8,2,50,2,6, // S0 to S9
  571. 7,10,20,0,138,0,0,0,30,2, // S10 to S19
  572. 0,193,64,0,1,176,48,0,0,0}, // S20 to S29
  574. // Factory Profile 1
  575. { 5,0,43,13,10,8,2,50,2,6, // S0 to S9
  576. 7,20,20,0,128,0,0,0,30,2, // S10 to S19
  577. 0,193,0,0,3,176,176,0,0,0} // S20 to S29
  578. };
  580. unsigned char i;
  582. volatile unsigned char bank2 * sregptr;
  584. if (settings <= 1)
  585. {
  586. sregptr = &S0;
  588. for(i=0; i < numsregs; i++)
  589. {
  590. *sregptr = sreginit[settings][i]; // Load S registers with initial settings
  591. sregptr++;
  592. }
  593. }
  594. }
  596. void init_micro()
  597. {
  598. OPTION = 0x00;
  599. STATUS = 0x00;
  600. PIR1 = 0x00;
  601. INTCON = 0x00;
  602. PIE1 = 0x00;
  603. }
  605. void init_ports()
  606. {
  607. TRISA = CONFIGPA; // Configure Port A
  608. TRISB = CONFIGPB; // Configure Port B
  609. TRISC = CONFIGPC; // Configure Port C
  611. ADCON1 = 0x06; // Port A no analog i/p's, all digital.
  613. PORTA = INITPA; // Initial Port A settings
  614. PORTB = INITPB; // Initial Port B settings
  615. PORTC = INITPC; // Initial Port C settings
  616. }
  618. void hook(unsigned char state) // State determines if on or off hook (State != 0 takes modem off-hook)
  619. {
  620. if (state == 0)
  621. {
  622. RLYDRV_ON = 0; // On-Hook
  623. }
  624. else
  625. {
  626. RLYDRV_ON = 1; // Off-Hook
  627. }
  629. wr16_cbus(CMXGENCTRL_ADDR,CMXGENCTRL); // Write General Control information to C-BUS.
  630. }
  632. void ringdetection() // Simple crude BT or Bell Ring Detect Check.  A valid ring consists of a burst greater
  633. // than 300ms then no ring detect when resampled 1 sec after burst ended.
  634. {
  635. if (POLLTMR == 0)
  636. {
  637. POLLTMR = 20; // Reload 20ms Ring detect sampling interval register
  638. if (!RDINPROG) // Check if ringing is in progress
  639. {
  640. RDCNT = 0; // Clear ring detect sample counter
  641. CMXSTAT = rd16_cbus(CMXSTAT_ADDR); // Read CMX868 Status reg and update shadow reg
  642. if (RDET) // Ring Detect Check 
  643. {
  644. S1 = 0; // Clear ring count S-register
  645. RDCNT++;
  646. RDTIMEOUT = 0; // Ensure ring detect timeout reg is clear at start
  647. RDINPROG = 1; // Set flag to indicate ringing in progress
  648. RIN = 0; // Clear RIN line
  649. }
  650. }
  651. else
  652. {
  653. if (RDTIMEOUT <= 70) // Check 8sec ring timeout timer has been running for at least 1sec
  654. {
  655. CMXSTAT = rd16_cbus(CMXSTAT_ADDR); // Read CMX868 Status reg and update shadow reg
  656. if (RDET) // Ring Detect Check 
  657. {
  658. RIN = 0; // Ensure RIN line is clear
  659. if (RDCNT != 255) // Prevent ring detect sample count reg from wrapping round
  660. {
  661. RDCNT++;
  662. }
  663. }
  664. else
  665. {
  666. RIN = 1; // Set RIN line
  667. if (RDCNT >= 15) // Check if ring burst exceeded 300ms
  668. {
  669. S1++; // Increment ring count S-register
  670. resmsgtopc(RING); // Send Ring message to terminal
  671.   if (S1 == S0)
  672. {
  673. RDINPROG = 0; // Initialise flag ready for next auto answer
  674. ATCMDMODE = 0; // Clear flag to indicate ready for handshaking
  675. ANSORIG = 0; // Clear flag to indicate answering
  676. }
  677. else
  678. {
  679. RDTIMEOUT = 80; // Reload 8sec ring detect timeout timer (100ms)
  680. RDCNT = 0; // Clear ring detect sample counter
  681. }
  682. }
  683. else
  684. {
  685. if (RDTIMEOUT == 0) // Abort ring detect validation if 8 sec timeout has occurred
  686. {
  687. RDINPROG = 0; // Initialise flag ready for next auto answer
  688. }
  689. }
  690. }
  691. }
  692. }
  693. }
  694. }
  696. void dial() // Dial routine Tx always enabled, alternates between DTMF and Notone
  697. {
  698. unsigned char i=0;
  700. CMXTXMODE &= 0x0E00;
  701. CMXTXMODE ^= 0x1000; // Select DTMF/Tones
  703. while (TELNUM[i] != NUL)
  704. {
  705. if (TELNUM[i] == ',') // Introduce delay dial sequence
  706. {
  707. Delay1s(S8);
  708. }
  709. else
  710. {
  711. CMXTXMODE ^= 0x0010; // Tx DTMF
  713. switch(TELNUM[i])
  714. {
  715. case 'A': case 'a':
  716. CMXTXMODE ^= DTMF_A;
  717. break;
  718. case 'B': case 'b':
  719. CMXTXMODE ^= DTMF_B;
  720. break;
  721. case 'C': case 'c':
  722. CMXTXMODE ^= DTMF_C;
  723. break;
  724. case 'D': case 'd':
  725. CMXTXMODE ^= DTMF_D;
  726. break;
  727. case '*':
  728. CMXTXMODE ^= DTMF_star;
  729. break;
  730. case '#':
  731. CMXTXMODE ^= DTMF_hash;
  732. break;
  733. case '0':
  734. CMXTXMODE ^= DTMF_0;
  735. break;
  736. default: // Numbers 1-9
  737. CMXTXMODE ^= (TELNUM[i] - 0x30);
  738. break;
  739. }
  741. wr16_cbus(CMXTXMODE_ADDR, CMXTXMODE);
  743. DelayMs(S11 * 10);
  745. CMXTXMODE &= 0xFF00; // Turn Tone Off
  747. wr16_cbus(CMXTXMODE_ADDR, CMXTXMODE);
  749. DelayMs(S11 * 10);
  750. }
  751. i++;
  752. }
  753. }
  755. void decnum2scrn(unsigned int value, unsigned char digits, unsigned char linefeed) // Number of digits and LF can be controlled
  756. {
  757. unsigned int k,quot,rem;
  759. if ((digits > 0) && (digits < 6)) 
  760. {
  761. rem = value;
  763. k=1;
  765. do
  766. {
  767. k *= 10; // Multiply k by 10
  769. digits--; // Decrement digits value
  771. } while (digits > 1);
  774. do
  775. {
  776. quot = rem / k;
  778. MSGBUF[MSGBUFLDPTR++] = (quot + 0x30) & 0xFF;// Load Message Buffer
  780. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  782. rem %= k;
  784. k /= 10;
  786. } while (k >= 1);
  788. }
  790. MSGBUF[MSGBUFLDPTR++] = S3; // Load Message Buffer with CR Char
  792. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  794. if (linefeed)
  795. {
  796. MSGBUF[MSGBUFLDPTR++] = S4; // Load Message Buffer with LF Char
  798. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  799. }
  801. TXIE=1; // Enable TX Interrupt
  803. while (TXIE)
  804. continue; // Wait until all characters have been sent to screen
  805. }
  807. void hexnum2scrn(unsigned int wordvalue, unsigned char digits, unsigned char linefeed) // LF can be controlled
  808. {
  809. unsigned char shift;
  811. unsigned char k;
  813. shift = 4 * digits;
  815. do
  816. {
  817. shift = shift - 4;
  819. k = (wordvalue >> shift) & 0x0F;
  821. if (k <= 9)
  822. {
  823. MSGBUF[MSGBUFLDPTR++] = (k + 0x30) & 0xFF; // Load Message Buffer
  824. }
  825. else
  826. {
  827. MSGBUF[MSGBUFLDPTR++] = (k + 0x37) & 0xFF; // Load Message Buffer
  828. }
  829. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  830. } while (shift != 0);
  832. MSGBUF[MSGBUFLDPTR++] = S3; // Load Message Buffer with CR Char
  834. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  836. if (linefeed)
  837. {
  838. MSGBUF[MSGBUFLDPTR++] = S4; // Load Message Buffer with LF Char
  840. MSGBUFLDPTR &= msgbufwrap; // Wrap round buffer if necessary
  841. }
  843. TXIE=1; // Enable TX Interrupt
  845. while (TXIE)
  846. continue; // Wait until all characters have been sent to screen
  847. }
  849. unsigned char dut_chksum() // Routine for extracting DSP ROM Checksums
  850. { // Assumes device is powered up
  851. do
  852. {
  853. CMXSTAT = rd16_cbus(CMXSTAT_ADDR);
  854. } while (!PROGFLAG); // Wait until Programming flag is set
  856. wr16_cbus(0xE9,0xC018); // Start DSP ROM Checksum Routine.
  858. do
  859. {
  860. CMXSTAT = rd16_cbus(CMXSTAT_ADDR);
  861. } while (!PROGFLAG); // Wait until Programming flag is set
  863. if (rd16_cbus(0xE5) != 0xFF54) // Check CMX868 XROM MS Word 
  864. {
  865. return(ERROR);
  866. }
  868. do
  869. {
  870. CMXSTAT = rd16_cbus(CMXSTAT_ADDR);
  871. } while (!PROGFLAG); // Wait until Programming flag is set
  873. if (rd16_cbus(0xEB) != 0x67A1) // Check CMX868 XROM LS Word 
  874. {
  875. return(ERROR);
  876. }
  878. do
  879. {
  880. CMXSTAT = rd16_cbus(CMXSTAT_ADDR);
  881. } while (!PROGFLAG); // Wait until Programming flag is set
  883. if (rd16_cbus(0xE5) != 0xFE35) // Check CMX868 PROM MS Word 
  884. {
  885. return(ERROR);
  886. }
  888. do
  889. {
  890. CMXSTAT = rd16_cbus(CMXSTAT_ADDR);
  891. } while (!PROGFLAG); // Wait until Programming flag is set
  893. if (rd16_cbus(0xEB) != 0x2C80) // Check CMX868 PROM LS Word 
  894. {
  895. return(ERROR);
  896. }
  898. return(OK);
  899. }
  901. void testfunc1()
  902. {
  903. CMXSTAT = rd16_cbus(CMXSTAT_ADDR); // Update CMX868 Status Shadow register
  905. if (HEXOP)
  906. {
  907. hexnum2scrn(CMXSTAT,4,WORDRES); // Send LF char if word results enabled
  908. }
  909. else
  910. {
  911. decnum2scrn(CMXSTAT,5,WORDRES); // Send LF char if word results enabled
  912. }
  914. GPT1 = S19; // Load GPT1(10ms) with S19 value
  916. if (GPT1 < 2)
  917. {
  918. GPT1 = 2; // Only allow 20ms minimum
  919. }
  920. while(GPT1 != 0) // Continue to loop until timer has expired
  921. continue;
  922. }