欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標(biāo)題: qn8025源程序 [打印本頁(yè)]
作者: aaa123451111    時(shí)間: 2018-7-21 20:28
標(biāo)題: qn8025源程序
  1. #include "qndriver.h"
  2. extern UINT8 QND_ReadReg(UINT8 adr);
  3. extern UINT8 QND_WriteReg(UINT8 adr, UINT8 value);

  5. #define R_TXRX_MASK    0xd0
  6. UINT8  S_XDATA  qnd_RSSIns = 255;
  7. UINT8  S_XDATA  qnd_Crystal = QND_CRYSTAL_DEFAULT;
  8. UINT8  S_XDATA  qnd_RSSIn[QND_BAND_NUM];
  9. UINT8  S_XDATA  qnd_PrevMode;
  10. UINT8  S_XDATA  qnd_Country  = COUNTRY_CHINA ;
  11. UINT16 S_XDATA  qnd_CH_START = 7600;
  12. UINT16 S_XDATA  qnd_CH_STOP  = 10800;
  13. UINT8  S_XDATA  qnd_CH_STEP  = 1;
  14. UINT8  qnd_ClearScanFlag = 0;
  15. UINT16 qnd_ClearChannel = 0;
  16. UINT8  qnd_FirstScan = 1;
  17. UINT8  S_XDATA qnd_AutoScanAll;
  18. UINT8  S_XDATA qnd_IsStereo;
  19. UINT8  S_XDATA qnd_ChCount;
  20. UINT16 S_XDATA  qnd_RSSInBB[QND_BAND_NUM+1];         
  21. UINT16 S_XDATA qnd_ChList[QN_CCA_MAX_CH];
  22. UINT8  S_XDATA  qnd_StepTbl[3]={5,10,20};
  23. QND_SeekCallBack qnd_CallBackFunc = 0;

  25. /**********************************************************************
  26. void QNF_RXInit()
  27. **********************************************************************
  28. Description: set to SNR based MPX control. Call this function before
  29.              tune to one specific channel
  30. Parameters:
  31. None
  32. Return Value:
  33. None
  34. **********************************************************************/
  35. void QNF_RXInit()
  36. {
  37.     QNF_SetRegBit(77,0x80,0x80);  // Set to High-Z
  38.     QNF_SetRegBit(40,0x80,0x80);  // Set SNR as criteria for MPX control
  39.     QNF_SetRegBit(64,0x3f,SMSTART_VAL); //set SMSTART
  40.     QNF_SetRegBit(66,0x3f,HCCSTART_VAL); //set HCCSTART
  41.     QNF_SetRegBit(65,0x7f,SNCSTART_VAL); //set SNCSTART
  42. }
  43. /**********************************************************************
  44. void QNF_SetMute(UINT8 On)
  45. **********************************************************************
  46. Description: set register specified bit
  47. Parameters:
  48. On:        1: mute, 0: unmute
  49. Return Value:
  50. None
  51. **********************************************************************/
  52. void QNF_SetMute(UINT8 On)
  53. {
  54.     if(On)
  55.     {
  56.         QNF_SetRegBit(REG_PD2, 0x0c, 0x0c); // mute/unmute to avoid noise   
  57.         //   QNF_SetRegBit(3, 0x80, 0x80); // mute/unmute to avoid noise   
  58.     }
  59.     else
  60.     {
  61.         QND_Delay(QND_DELAY_BEFORE_UNMUTE);
  62.         QNF_SetRegBit(REG_PD2, 0x0c, 0x00); // mute/unmute to avoid noise   
  63.         //   QND_Delay(50);
  64.      //   QNF_SetRegBit(3, 0x80, 0x00); // mute/unmute to avoid noise   
  65.     }
  66. }
  67. /**********************************************************************
  68. void QNF_SetRegBit(UINT8 reg, UINT8 bitMask, UINT8 data_val)
  69. **********************************************************************
  70. Description: set register specified bit
  71. Parameters:
  72.     reg:        register that will be set
  73.     bitMask:    mask specified bit of register
  74.     data_val:    data will be set for specified bit
  75. Return Value:
  76.     None
  77. **********************************************************************/
  78. void QNF_SetRegBit(UINT8 reg, UINT8 bitMask, UINT8 data_val)
  79. {
  80.     UINT8 temp;
  81.     temp = QND_ReadReg(reg);
  82.     temp &= (UINT8)(~bitMask);
  83.     temp |= data_val & bitMask;
  84. //    temp |= data_val;
  85.     QND_WriteReg(reg, temp);
  86. }
  87. /**********************************************************************
  88. void QNF_InitRSSInBB()
  89. **********************************************************************
  90. Description: init RSSI noise floor band
  91. Parameters:
  92.     None
  93. Return Value:
  94.     None
  95. **********************************************************************/
  96. void QNF_InitRSSInBB()
  97. {
  98.     UINT8 i,d2,d,step;
  99.     UINT16 d1;
  100.     // get frequency leap step
  101.     step = qnd_StepTbl[qnd_CH_STEP];
  102.     // total frequency span
  103.     d1 = qnd_CH_STOP - qnd_CH_START;
  104.     // make sure d2 value <= 255, normally QND_BAND_NUM should < 10
  105.     d2 = step * QND_BAND_NUM;
  106.     d = d1/d2;
  107.     // first one should be CH_START
  108.     qnd_RSSInBB[0] = qnd_CH_START;
  109.     for(i=1; i<QND_BAND_NUM; i++) {
  110.         qnd_RSSInBB[i] = qnd_RSSInBB[i-1] + d * step;
  111.     }
  112.     // last one set one more step higher for convenience
  113.     qnd_RSSInBB[i] = qnd_CH_STOP+step;
  114. }
  115. /**********************************************************************
  116. UINT8 QNF_GetRSSInBandIndex(UINT16 chfreq)
  117. **********************************************************************
  118. Description: get band index
  119. Parameters:
  120.     chfreq: channel frequency (10Khz unit, eg: for 101.10Mhz, input 10110)
  121. Return Value: band index for input CH frequency
  122. **********************************************************************/
  123. UINT8 QNF_GetRSSInBandIndex(UINT16 chfreq)  
  124. {
  125.     UINT8 i;
  126.     for(i=0; i<QND_BAND_NUM; i++) {
  127.         if(chfreq < qnd_RSSInBB[i+1]) {
  128.             // finally come to here, if no wrong input
  129.             return i;
  130.         }
  131.     }
  132. }
  133. /**********************************************************************
  134. UINT8 QNF_GetRSSIn(UINT16 chFreq)
  135. **********************************************************************
  136. Description: get RSSI noise floor
  137. Parameters:
  138.     chfreq: channel frequency (10Khz unit, eg: for 101.10Mhz, input 10110)
  139. Return Value:
  140.     the RSSI noise floor
  141. **********************************************************************/
  142. UINT8 QNF_GetRSSIn(UINT16 chFreq)
  143. {
  144.     UINT8 idx;
  145.     idx = QNF_GetRSSInBandIndex(chFreq);
  146.     return qnd_RSSIn[idx];
  147. }
  148. /**********************************************************************
  149. UINT16 QNF_GetCh()
  150. **********************************************************************
  151. Description: get current channel frequency
  152. Parameters:
  153.     None
  154. Return Value:
  155.     channel frequency
  156. **********************************************************************/
  157. UINT16 QNF_GetCh()
  158. {
  159.     UINT8 tCh;
  160.     UINT8  tStep;
  161.     UINT16 ch = 0;
  162.     // set to reg: CH_STEP
  163.     tStep = QND_ReadReg(CH_STEP);
  164.     tStep &= CH_CH;
  165.     ch  =  tStep ;
  166.     tCh= QND_ReadReg(CH);   
  167.     ch = (ch<<8)+tCh;
  168.     return CHREG2FREQ(ch);
  169. }
  170. /**********************************************************************
  171. UINT8 QNF_SetCh(UINT16 freq)
  172. **********************************************************************
  173. Description: set channel frequency
  174. Parameters:
  175.     freq:  channel frequency to be set
  176. Return Value:
  177.     1: success
  178. **********************************************************************/
  179. UINT8 QNF_SetCh(UINT16 freq)
  180. {
  181.     // calculate ch parameter used for register setting
  182.     UINT8 tStep;
  183.     UINT8 tCh;
  184.     UINT16 f;
  185.         f = FREQ2CHREG(freq);
  186.         // set to reg: CH
  187.         tCh = (UINT8) f;
  188.         QND_WriteReg(CH, tCh);
  189.         // set to reg: CH_STEP
  190.         tStep = QND_ReadReg(CH_STEP);
  191.         tStep &= ~CH_CH;
  192.         tStep |= ((UINT8) (f >> 8) & CH_CH);
  193.         QND_WriteReg(CH_STEP, tStep);
  194.     return 1;
  195. }
  196. /**********************************************************************
  197. void QNF_ConfigScan(UINT16 start,UINT16 stop, UINT8 step)
  198. **********************************************************************
  199. Description: config start, stop, step register for FM/AM CCA or CCS
  200. Parameters:
  201.     start
  202.         Set the frequency (10kHz) where scan to be started,
  203.         eg: 7600 for 76.00MHz.
  204.     stop
  205.         Set the frequency (10kHz) where scan to be stopped,
  206.         eg: 10800 for 108.00MHz
  207.     step        
  208.         1: set leap step to (FM)100kHz / 10kHz(AM)
  209.         2: set leap step to (FM)200kHz / 1kHz(AM)
  210.         0:  set leap step to (FM)50kHz / 9kHz(AM)
  211. Return Value:
  212.          None
  213. **********************************************************************/
  214. void QNF_ConfigScan(UINT16 start,UINT16 stop, UINT8 step)
  215. {
  216.     // calculate ch para
  217.     UINT8 tStep = 0;
  218.     UINT8 tS;
  219.     UINT16 fStart;
  220.     UINT16 fStop;
  221.         fStart = FREQ2CHREG(start);
  222.         fStop = FREQ2CHREG(stop);
  223.         // set to reg: CH_START
  224.     tS = (UINT8) fStart;
  225.     QND_WriteReg(CH_START, tS);
  226.     tStep |= ((UINT8) (fStart >> 6) & CH_CH_START);
  227.     // set to reg: CH_STOP
  228.     tS = (UINT8) fStop;
  229.     QND_WriteReg(CH_STOP, tS);
  230.     tStep |= ((UINT8) (fStop >> 4) & CH_CH_STOP);
  231.     // set to reg: CH_STEP
  232.     tStep |= step << 6;
  233.     QND_WriteReg(CH_STEP, tStep);
  234. }
  235. /**********************************************************************
  236. void QNF_SetAudioMono(UINT8 modemask, UINT8 mode)
  237. **********************************************************************
  238. Description:    Set audio output to mono.
  239. Parameters:
  240.   modemask: mask register specified bit
  241.   mode
  242.         QND_RX_AUDIO_MONO:    RX audio to mono
  243.         QND_RX_AUDIO_STEREO:  RX audio to stereo   
  244.         QND_TX_AUDIO_MONO:    TX audio to mono
  245.         QND_TX_AUDIO_STEREO:  TX audio to stereo
  246. Return Value:
  247.   None
  248. **********************************************************************/
  249. void QNF_SetAudioMono(UINT8 modemask, UINT8 mode)
  250. {
  251.     if (mode == QND_TX_AUDIO_MONO||mode == QND_RX_AUDIO_MONO)
  252.     {
  253.         // set to 22.5K (22.5/0.69 ~= 32)
  254.         QND_WriteReg(TX_FDEV, 0x20);
  255.     }
  256.     else
  257.     {
  258.         // back to default
  259.         QND_WriteReg(TX_FDEV, 0x6c);
  260.     }
  261.     QNF_SetRegBit(SYSTEM2,modemask, mode);
  262. }
  263. /**********************************************************************
  264. void QNF_UpdateRSSIn(UINT16 chFreq)
  265. **********************************************************************
  266. Description: update the qnd_RSSIns and qnd_RSSIn value              
  267. Parameters:
  268.     None
  269. Return Value:
  270.     None
  271. **********************************************************************/
  272. void  QNF_UpdateRSSIn(UINT16 chFreq)
  273. {
  274.     UINT8 i,j;
  275.     UINT8 r0;
  276.     UINT16 ch;
  277.     // backup SYSTEM1 register
  278.     r0 = QND_ReadReg(SYSTEM1);
  279.     if(!chFreq)
  280.     {
  281.         for (i = 0 ; i < QND_BAND_NUM; i++)
  282.         {
  283.             ch = QND_TXClearChannelScan(qnd_RSSInBB[i], qnd_RSSInBB[i+1]-qnd_StepTbl[qnd_CH_STEP], qnd_CH_STEP, 15);
  284.             qnd_RSSIn[i] = QND_GetRSSI(ch);
  285.             if (qnd_RSSIns > qnd_RSSIn[i])
  286.             {
  287.                 qnd_RSSIns = qnd_RSSIn[i];
  288.                 qnd_ClearChannel = ch;
  289.             }
  290.         }
  291.     }
  292.     else
  293.     {
  294.         i = QNF_GetRSSInBandIndex(chFreq);
  295.         ch = QND_TXClearChannelScan(qnd_RSSInBB[i], qnd_RSSInBB[i+1]-qnd_StepTbl[qnd_CH_STEP], qnd_CH_STEP, 15);
  296.         qnd_RSSIn[i] = QND_GetRSSI(ch);
  297.     }
  298.     // restore SYSTEM1 register
  299.     QND_WriteReg(SYSTEM1, r0);
  300. }
  301. /**********************************************************************
  302. int QND_Delay()
  303. **********************************************************************
  304. Description: Delay for some ms, to be customized according to user
  305.              application platform
  306. Parameters:
  307.         ms: ms counts
  308. Return Value:
  309.         None
  310.             
  311. **********************************************************************/
  312. void QND_Delay(UINT16 ms)
  313. {
  314.     UINT16 i,k;
  315.     for(i=0; i<3000;i++)
  316.     {   
  317.         for(k=0; k<ms; k++)
  318.         {
  319.         }
  320.     }
  321. }
  322. /**********************************************************************
  323. UINT8 QND_GetRSSI(UINT16 ch)
  324. **********************************************************************
  325. Description:    Get the RSSI value
  326. Parameters:
  327. Return Value:
  328. RSSI value  of the channel setted
  329. **********************************************************************/
  330. UINT8 QND_GetRSSI(UINT16 ch)
  331. {
  332.     UINT8 delayTime;
  333.     {
  334.         QND_SetSysMode(QND_MODE_RX|QND_MODE_FM);
  335.         delayTime = QND_READ_RSSI_DELAY;
  336.     }
  337.     QNF_SetCh(ch);
  338.     QNF_SetRegBit(SYSTEM1, CCA_CH_DIS, CCA_CH_DIS);   
  339.     QND_Delay(delayTime);
  340.     return QND_ReadReg(RSSISIG);  
  341. }
  342. /**********************************************************************
  343. void QN_ChipInitialization()
  344. **********************************************************************
  345. Description: chip first step initialization, called only by QND_Init()
  346. Parameters:
  347.     None
  348. Return Value:
  349.     None
  350. **********************************************************************/
  351. void QN_ChipInitialization()
  352. {
  353.     QND_WriteReg(0x01,0x89);  //sw reset
  354.     QND_WriteReg(0x50,0x00);
  355.     QND_WriteReg(0x01,0x49);  //recalibrate
  356.     QND_WriteReg(0x01,0x09);
  357.     QND_Delay(40);           //wait more than 400ms
  358.     QND_WriteReg(0x3C,0x89);  //for RDS SYNC
  359.     QNF_SetRegBit(0x49,0xc0, 0x00);
  360.     QND_WriteReg(0x4a,0xba);
  361.     QND_WriteReg(0x5c,0x05);
  362.     QND_WriteReg(0x52,0x0c);
  363.     QNF_SetRegBit(49,0x30,0x00); //minimize rxagc_timeout; WQF0717
  364.     QND_WriteReg(0x38,0x2d);  //for SNR CCA ccnclk2=2'b00
  365.     QND_WriteReg(0x39,0x88);  //for SNR CCA ccnclk1=2'b00
  366.     QND_WriteReg(0x52,0x0c);  //mute
  367.     QND_WriteReg(0x00,0x81);
  368.     QND_WriteReg(0x57,0x80);
  369.     QND_WriteReg(0x57,0x00);
  370.     QND_Delay(10);           //wait more than 100ms
  371.     QND_WriteReg(0x00,0x01);
  372.     QND_WriteReg(0x52,0x00);
  373.     QNF_SetRegBit(31,0x38,0x28);  //WQF0717
  374.     //WQF0717  
  375.     QND_WriteReg(HYSTERSIS, 0xff);
  376.     QND_WriteReg(MPSTART, 0x12);
  377.     QNF_SetRegBit(58,0xf,0xf);//set ccth11
  378. }
  379. /**********************************************************************
  380. void QND_LoadDefalutSetting(UINT8 country)
  381. **********************************************************************
  382. Description: load some defalut setting for a certain country
  383. Parameters:
  384.     country :
  385.     COUNTRY_CHINA: China
  386.     COUNTRY_USA: USA
  387.     COUNTRY_JAPAN: Japan (not supported yet)
  388. Return Value:
  389.     None
  390. **********************************************************************/
  391. void QND_LoadDefalutSetting(UINT8 country)
  392. {
  393.     switch(country)
  394.     {
  395.     case COUNTRY_CHINA:
  396.         break;
  397.     case COUNTRY_USA:
  398.         QND_ConfigFMModule(QND_CONFIG_AUDIOPEAK_DEV,75);
  399.         QND_ConfigFMModule(QND_CONFIG_PILOT_DEV,9);
  400.         QND_ConfigFMModule(QND_CONFIG_RDS_DEV,2);
  401.         QNF_SetRegBit(0x01,0x08,0x08);
  402.         QNF_SetRegBit(0x04,0x3f,0x3f);
  403.         QND_TXConfigAudio(QND_CONFIG_SOFTCLIP,1);
  404.         break;
  405.     case COUNTRY_JAPAN:
  406.         break;
  407.     default:
  408.         break;
  409.     }
  410. }
  411. /**********************************************************************
  412. int QND_Init()
  413. **********************************************************************
  414. Description: Initialize device to make it ready to have all functionality ready for use.
  415. Parameters:
  416.     None
  417. Return Value:
  418.     1: Device is ready to use.
  419.     0: Device is not ready to serve function.
  420. **********************************************************************/
  421. UINT8 QND_Init()
  422. {
  423.     QN_ChipInitialization();
  424.     QNF_SetMute(1);
  425.     QNF_InitRSSInBB();    // init band range
  426.     QND_WriteReg(0x00,  0x01); //resume original status of chip /* 2008 06 13 */
  427.     QNF_SetMute(0);
  428.     return 1;
  429. }
  430. /**********************************************************************
  431. void QND_SetSysMode(UINT16 mode)
  432. ***********************************************************************
  433. Description: Set device system mode(like: sleep ,wakeup etc)
  434. Parameters:
  435.     mode:  set the system mode , it will be set by  some macro define usually:
  436.    
  437.     SLEEP (added prefix: QND_MODE_, same as below):  set chip to sleep mode
  438.     WAKEUP: wake up chip
  439.     TX:     set chip work on TX mode
  440.     RX:     set chip work on RX mode
  441.     FM:     set chip work on FM mode
  442.     AM:     set chip work on AM mode
  443.     TX|FM:  set chip work on FM,TX mode
  444.     RX|AM;  set chip work on AM,RX mode
  445.     RX|FM:    set chip work on FM,RX mode
  446. Return Value:
  447.     None     
  448. **********************************************************************/
  449. void QND_SetSysMode(UINT16 mode)
  450. {   
  451.     UINT8 val;
  452.     switch(mode)        
  453.     {        
  454.     case QND_MODE_SLEEP:                       //set sleep mode        
  455.         qnd_PrevMode = QND_ReadReg(SYSTEM1);        
  456.         QNF_SetRegBit(SYSTEM1, R_TXRX_MASK, STNBY);         
  457.         break;        
  458.     case QND_MODE_WAKEUP:                      //set wakeup mode        
  459.         QND_WriteReg(SYSTEM1, qnd_PrevMode);        
  460.         break;        
  461.     case QND_MODE_DEFAULT:
  462.         QNF_SetRegBit(SYSTEM2,0x80,0x80);
  463.         break;
  464.     default:   
  465.             val = (UINT8)(mode >> 8);        
  466.             if (val)
  467.             {
  468.                     if(val == (QND_MODE_TX >> 8))
  469.                     {
  470.                         QND_WriteReg(73, 0x44);
  471.                     }
  472.                     else if(val == (QND_MODE_RX >> 8))
  473.                     {
  474.                         QND_WriteReg(73, 0x04);
  475.                     }                        
  476.                     // set to new mode if it's not same as old
  477.                     if((QND_ReadReg(SYSTEM1) & R_TXRX_MASK) != val)
  478.                     {
  479.                         QNF_SetMute(1);
  480.                         QNF_SetRegBit(SYSTEM1, R_TXRX_MASK, val);
  481.                         //   QNF_SetMute(0);
  482.                     }
  483.                     // make sure it's working on analog output
  484.                     QNF_SetRegBit(SYSTEM1, 0x08, 0x00);   
  485.             }   
  486.         break;        
  487.     }   
  488. }
  489. /**********************************************************************
  490. void QND_TuneToCH(UINT16 ch)
  491. **********************************************************************
  492. Description: Tune to the specific channel. call QND_SetSysMode() before
  493.     call this function
  494. Parameters:
  495.     ch
  496.     Set the frequency (10kHz) to be tuned,
  497.     eg: 101.30MHz will be set to 10130.
  498. Return Value:
  499.     None
  500. **********************************************************************/
  501. void QND_TuneToCH(UINT16 ch)
  502. {
  503.     UINT8 rssi;
  504.     UINT8 minrssi;
  505.     QNF_RXInit();
  506.     // if chip working on TX mode, just set CH
  507.     if(QND_ReadReg(SYSTEM1) & TXREQ)
  508.     {
  509.         QNF_SetRegBit(SYSTEM1, CCA_CH_DIS, CCA_CH_DIS);
  510.         QNF_SetCh(ch);   
  511.         return;
  512.     }
  513.     QNF_SetMute(1);
  514.     if ((ch - 7710) % 240 == 0)
  515.     {
  516.         QNF_SetRegBit(TXAGC_GAIN, IMR, IMR);
  517.     }
  518.     else
  519.     {
  520.         QNF_SetRegBit(TXAGC_GAIN, IMR, 0x00);
  521.     }
  522.     QNF_SetCh(ch);
  523.     QNF_SetRegBit(SYSTEM1, CCA_CH_DIS, CCA_CH_DIS);
  524.     //Free filter without RDS and Set filter 2 for Non-RDS
  525.     QNF_SetRegBit(GAIN_SEL,0x38,(QND_ReadReg(SYSTEM2) & 0x20) ? 0x00 : 0x28);
  526.     QNF_SetMute(0);
  527. }
  528. /**********************************************************************
  529. void QND_SetCountry(UINT8 country)
  530. ***********************************************************************
  531. Description: Set start, stop, step for RX and TX based on different
  532.              country
  533. Parameters:
  534. country:
  535. Set the chip used in specified country:
  536.     CHINA:
  537.     USA:
  538.     JAPAN:
  539. Return Value:
  540.     None     
  541. **********************************************************************/
  542. void QND_SetCountry(UINT8 country)
  543. {
  544.     qnd_Country = country;
  545.     switch(country)
  546.     {
  547.     case COUNTRY_CHINA:
  548.         qnd_CH_START = 7600;
  549.         qnd_CH_STOP = 10800;
  550.         qnd_CH_STEP = 1;
  551.         break;
  552.     case COUNTRY_USA:
  553.         qnd_CH_START = 8810;
  554.         qnd_CH_STOP = 10790;
  555.         qnd_CH_STEP = 2;
  556.         break;
  557.     case COUNTRY_JAPAN:
  558.         break;
  559.     }
  560. }
  561. /**********************************************************************
  562. void QND_UpdateRSSIn(UINT16 ch)
  563. **********************************************************************
  564. Description: in case of environment changed, we need to update RSSI noise floor
  565. Parameters:
  566.     None
  567. Return Value:
  568.     None
  569. **********************************************************************/
  570. void QND_UpdateRSSIn(UINT16 ch)
  571. {
  572.     UINT8 temp;
  573.     UINT8 v_abs;
  574.     if (qnd_FirstScan == 0 )
  575.     {
  576.         temp = QND_GetRSSI(qnd_ClearChannel);
  577.         if(temp > qnd_RSSIns)
  578.         {
  579.             v_abs = temp - qnd_RSSIns;
  580.         }
  581.         else
  582.         {
  583.             v_abs = qnd_RSSIns - temp;
  584.         }
  585.         if (v_abs< RSSINTHRESHOLD)
  586.         {
  587.             qnd_ClearScanFlag = 0;   
  588.         }
  589.         else
  590.         {
  591.             qnd_ClearScanFlag = 1;
  592.         }
  593.     }
  594.     if (qnd_ClearScanFlag||qnd_FirstScan||ch)
  595.     {
  596.         QNF_UpdateRSSIn(ch);
  597.         qnd_FirstScan = 0;
  598.     }
  599.     return;
  600. }
  601. /**********************************************************************
  602. void QND_ConfigFMModule(UINT8 optiontype, UINT8 option)
  603. ***********************************************************************
  604. Description: Config the FM modulation setting
  605. country
  606. Parameters:
  607.   optiontype:
  608.     QND_CONFIG_AUDIOPEAK_DEV : audio peak deviation
  609.     QND_CONFIG_PILOT_DEV:      pilot deviation
  610.     QND_CONFIG_RDS_DEV:        rds deviation  
  611.   option:
  612.     QND_CONFIG_AUDIOPEAK_DEV: 0~165khz
  613.     QND_CONFIG_PILOT_DEV:     8~10
  614.     QND_CONFIG_RDS_DEV:       1~7.5khz
  615. Return Value:
  616.     None     
  617. **********************************************************************/
  618. void QND_ConfigFMModule(UINT8 optiontype, UINT8 option)
  619. {
  620.     UINT8  tmp8;
  621.     UINT16 tmp16;
  622.     switch (optiontype)
  623.     {
  624.     case QND_CONFIG_AUDIOPEAK_DEV:
  625.         tmp16 = option*100;
  626.         tmp8  = tmp16/69;
  627.         QND_WriteReg(0x0e,tmp8);
  628.         break;
  629.     case QND_CONFIG_PILOT_DEV:
  630.         tmp8 = option<<2;
  631.         QNF_SetRegBit(0x0f,0x3c,tmp8);
  632.         break;
  633.     case QND_CONFIG_RDS_DEV:
  634.         tmp16 = option*100;
  635.         tmp8  = tmp16/35;
  636.         QNF_SetRegBit(0x18,0x7f,tmp8);
  637.         break;
  638.     default:
  639.         break;
  640.     }
  641. }
  642. /***********************************************************************
  643. Description: set call back function which can be called between seeking
  644. channel
  645. Parameters:
  646. func : the function will be called between seeking
  647. Return Value:
  648. None
  649. **********************************************************************/
  650. void QND_SetSeekCallBack(QND_SeekCallBack func)
  651. {
  652.     qnd_CallBackFunc = func;
  653. }
  654. /***********************************************************************
  655. UINT16 QND_RXSeekCH(UINT16 start, UINT16 stop, UINT16 step, UINT8 snr_th, UINT8 up);
  656. ***********************************************************************
  657. Description: Automatically scans the frequency range, and detects the
  658.   first channel(AM or FM, it will be determine by the system mode which set
  659.   by QND_SetSysMode).
  660.   A threshold value needs to be passed in for channel detection.
  661. Parameters:
  662. start
  663.   Set the frequency (10kHz) where scan will be started,
  664.   eg: 76.00MHz will be set to 7600.
  665. stop
  666.   Set the frequency (10kHz) where scan will be stopped,
  667.   eg: 108.00MHz will be set to 10800.
  668. step
  669.   FM:
  670.    QND_FMSTEP_100KHZ: set leap step to 100kHz
  671.    QND_FMSTEP_200KHZ: set leap step to 200kHz
  672.    QND_FMSTEP_50KHZ:  set leap step to 50kHz
  673.   AM:
  674.    QND_AMSTEP_***:
  675. snr_th:
  676.   Set threshold for quality of channel to be searched.
  677. up:
  678.   Set the seach direction :
  679.    Up;0,seach from stop to start
  680.    Up:1 seach from start to stop
  681. Return Value:
  682.   The channel frequency (unit: 10kHz)
  683.   -1: no channel found
  684. ***********************************************************************/
  685. UINT16 QND_RXSeekCH(UINT16 start, UINT16 stop, UINT8 step, UINT8 db, UINT8 up)
  686. {
  687.     UINT8 regValue;
  688.     UINT16 c, chfreq;
  689.     UINT16 ifcnt;
  690.     UINT8 savevalue;
  691.     UINT8 rssi,mprssi;
  692.     UINT8 scanFlag = 1;
  693.     UINT8 stepvalue;
  694.     UINT8 timeout = 0;
  695.     UINT8 pilot_snr;
  696.     UINT8 minrssi;
  697.     if (qnd_AutoScanAll == 0)
  698.     {
  699.         QNF_SetMute(1);
  700.         QNF_SetRegBit(GAIN_SEL,0x38,0x38);
  701.         QND_UpdateRSSIn(0);
  702.     }
  703.     up=(start<stop) ? 1 : 0;
  704.     stepvalue = qnd_StepTbl[step];
  705.     do
  706.     {
  707.         minrssi = QNF_GetRSSIn(start);
  708.         QNF_SetCh(start);
  709.         c = start;
  710.         if ((c - 7710) % 240 == 0)
  711.         {   
  712.             QNF_SetRegBit(TXAGC_GAIN, IMR, IMR);
  713.         }
  714.         else
  715.         {
  716.             QNF_SetRegBit(TXAGC_GAIN, IMR, 0);
  717.         }
  718.         QNF_SetRegBit(SYSTEM1,0xA1,0x81);
  719.         QND_Delay(10); //10ms delay
  720.         rssi = QND_ReadReg(RSSISIG); //read RSSI
  721.         if (rssi > minrssi+6+db)
  722.         {
  723.             QNF_ConfigScan(start, start, step);
  724.             QNM_SetRxThreshold(minrssi-22+db);
  725.             QNF_SetRegBit(SYSTEM1,0xA1,0xA0);
  726.             timeout = 0;
  727.             do
  728.             {
  729.                 QND_Delay(5);
  730.                 regValue = QND_ReadReg(SYSTEM1);
  731.                 timeout++;
  732.             }
  733.             while((regValue &CHSC)&&timeout < 200);
  734.             if (timeout < 200)
  735.             {
  736.                 regValue = QND_ReadReg(CCA5);
  737.                 ifcnt = regValue;
  738.                 regValue = QND_ReadReg(CCA4);
  739.                 ifcnt =(((ifcnt&0x1f)<<8)+regValue);
  740.                 if ((ifcnt < 2268) && (ifcnt > 1828))
  741.                 {
  742.                     if (rssi > minrssi + 20 + db)
  743.                     {
  744.                         scanFlag = 0;
  745.                     }
  746.                     else
  747.                     {
  748.                         QND_Delay(PILOT_READ_OUT_DELAY_TIME);
  749.                         pilot_snr = (QND_ReadReg(STATUS1) & 0x01) ? 0 : 1;   
  750.                         if (pilot_snr)
  751.                         {
  752.                             scanFlag = 0;
  753.                         }            
  754.                         else
  755.                         {
  756.                             QND_Delay(PILOT_SNR_READ_OUT_DELAY_TIME);
  757.                             pilot_snr = QND_ReadReg(SNR);  
  758.                             if (pilot_snr > 5 && pilot_snr < 55)
  759.                             {
  760.                                 scanFlag = 0;
  761.                             }
  762.                         }
  763.                     }
  764.                 }
  765.             }
  766.         }
  767.         chfreq = start;
  768.         if (scanFlag)
  769.         {
  770.             start = chfreq + (up ? stepvalue : -stepvalue);
  771.             if ((up && (stop < start)) || (!up && (start < stop)))
  772.             {
  773.                 scanFlag = 0;
  774.                 chfreq = 0;
  775.             }
  776.         }
  777.         else
  778.         {
  779.             if(qnd_CallBackFunc)
  780.                 qnd_CallBackFunc(chfreq, BAND_FM);
  781.         }
  782.     }
  783.     while (scanFlag != 0);
  784.     if (qnd_AutoScanAll == 0)
  785.     {
  786.         //Move the filter setting to TunetoChannel
  787.         //QNF_SetRegBit(32,0x08,0x08);
  788.         QND_TuneToCH((chfreq==0) ? stop: chfreq);
  789.     }
  790.     //QND_LOG("=== Done QND_AutoScan_FMChannel_One ===");
  791.     return chfreq;  
  792. }
  793. /**********************************************************************
  794. UINT8 QND_RXSeekCHAll(UINT16 start, UINT16 stop, UINT16 step, UINT8 db, UINT8 up)
  795. **********************************************************************
  796. Description:    Automatically scans the complete FM or AM band and detects
  797.             all the available  channels(AM or FM, it will be determine by
  798.             the workmode which set by QND_SetSysmode). A threshold value
  799.             needs to be passed in for the channel detection.
  800. Parameters:
  801.     start
  802.         Set the frequency (10kHz) where scan will be started,
  803.         eg: 76.00MHz will be set to 7600.
  804.     stop
  805.         Set the frequency (10kHz) where scan will be stopped,
  806.         eg: 108.00MHz will be set to 10800.
  807.     Step
  808.         FM:
  809.             QND_FMSTEP_100KHZ: set leap step to 100kHz
  810.             QND_FMSTEP_200KHZ: set leap step to 200kHz
  811.             QND_FMSTEP_50KHZ:  set leap step to 50kHz
  812.         AM:
  813.         QND_AMSTEP_***:
  814.     db
  815.         Set signal noise ratio for channel to be searched.
  816.     up:
  817.         Set the seach direction :
  818.         Up;0,seach from stop to start
  819.         Up:1 seach from start to stop
  820. Return Value:
  821.   The channel count found by this function
  822.   -1: no channel found
  823. **********************************************************************/
  824. UINT8 QND_RXSeekCHAll(UINT16 start, UINT16 stop, UINT8 step, UINT8 db, UINT8 up)
  825. {
  826.     UINT16 prevCh = 0;
  827.     //UINT16 chfreq;
  828.     UINT8  stepvalue;
  829.     UINT16 temp;
  830.     UINT16 pStart = start;
  831.     UINT16 pStop = stop > qnd_CH_STOP ? qnd_CH_STOP : stop;
  832.     QNF_SetMute(1);
  833.     up=(start<stop) ? 1 : 0;
  834.     qnd_AutoScanAll = 1;
  835.     stepvalue = qnd_StepTbl[step];
  836.     QNF_SetRegBit(GAIN_SEL,0x38,0x38);
  837.     {
  838.         QND_UpdateRSSIn(0);
  839.     }
  840.     qnd_ChCount = 0;
  841.     do
  842.     {  
  843.         temp = QND_RXSeekCH(pStart, pStop, step, db, up);
  844.         if (temp)
  845.         {
  846.             qnd_ChList[qnd_ChCount++] =temp;
  847.         }
  848.         else
  849.         {
  850.             temp = pStop;
  851.         }
  852.         {
  853.             pStart = temp + (up ? stepvalue : -stepvalue);
  854.         }
  855.     }
  856.     while((up ? (pStart<=pStop):(pStart>=pStop)) && (qnd_ChCount < QN_CCA_MAX_CH));
  857.     QND_TuneToCH((qnd_ChCount >= 1)? qnd_ChList[0] : pStop);
  858.     qnd_AutoScanAll = 0;
  859.     QNF_SetMute(0);
  860.     return qnd_ChCount;
  861. }
  862. /************************************************************************
  863. void QND_RXConfigAudio(UINT8 optiontype, UINT8 option )
  864. *************************************************************************
  865. Description: config audio
  866. Parameters:
  867.   optiontype: option
  868.     QND_CONFIG_MUTE; ‘option’control muteable, 0:mutedisable,1:mute enable
  869.     QND_CONFIG_MONO; ‘option’control mono, 0: QND_AUDIO_STEREO,1: QND_AUDIO_STEREO
  870.     QND_CONFIG_EQUALIZER: 'option' control the EQUALIZER,0:disable  EQUALIZER; 1: enable EQUALIZER;
  871.     QND_CONFIG_VOLUME: 'option' control the volume gain,range : 0~83(0: -65db, 65: 0db, 83: +18db
  872.     QND_CONFIG_BASS_QUALITY: 'option' set BASS quality factor,0: 1, 1: 1.25, 2: 1.5, 3: 2
  873.     QND_CONFIG_BASS_FREQ: 'option' set BASS central frequency,0: 60Hz, 1: 70Hz, 2: 80Hz, 3: 100Hz
  874.     QND_CONFIG_BASS_GAIN: 'option' set BASS control gain,range : 0x0~0x1e (00000 :-15db, 11110 :15db
  875.     QND_CONFIG_MID_QUALITY: 'option' set MID quality factor,0 :1, 1 :2
  876.     QND_CONFIG_MID_FREQ: 'option' set MID central frequency,0: 0.5KHz, 1: 1KHz, 2: 1.5KHz, 3: 2KHz
  877.     QND_CONFIG_MID_GAIN: 'option' set MID control gain,range : 0x0~0x1e (00000 :-15db, 11110 :15db)
  878.     QND_CONFIG_TREBLE_FREQ: 'option' set TREBLE central frequency,0: 10KHz, 1: 12.5KHz, 2: 15KHz, 3: 17.5KHz
  879.     QND_CONFIG_TREBLE_GAIN: 'option' set TREBLE control gain,range : 0x0~0x1e (00000 :-15db, 11110 :15db
  880. Return Value:
  881.     none
  882. **********************************************************************/
  883. void QND_RXConfigAudio(UINT8 optiontype, UINT8 option )
  884. {
  885.     switch(optiontype)
  886.     {
  887.     case QND_CONFIG_MONO:
  888.         if (option)
  889.             QNF_SetAudioMono(RX_MONO_MASK, QND_RX_AUDIO_MONO);
  890.         else
  891.             QNF_SetAudioMono(RX_MONO_MASK, QND_RX_AUDIO_STEREO);
  892.         break;
  893.     case QND_CONFIG_MUTE:
  894.         if (option)
  895.             QNF_SetMute(1);
  896.         else
  897.             QNF_SetMute(0);
  898.         break;
  899.     default:
  900.         break;
  901.     }
  902. }
  903. /**********************************************************************
  904. UINT16 QND_TXClearChannelScan(UINT16 start, UINT16 stop, UINT16 step,UINT8 db)
  905. **********************************************************************
  906. Description:    Clean channel scan. Finds the best clear channel for transmission.
  907. Parameters:
  908.   Start
  909.     Set the frequency (10kHz) where scan will be started,
  910.     eg: 7600 for 76.00MHz
  911.   Stop
  912.     Set the frequency (10kHz) where scan will be stopped,
  913.     eg: 10800 for 108.00MHz
  914.   Step
  915.     QND_FSTEP_100KHZ: Set leap step to 100kHz.
  916.     QND_FSTEP_200KHZ: Set leap step to 200kHz.
  917.     QND_FSTEP_50KHZ:  Set leap step to 50kHz.
  918.   db
  919.     Set threshold for quality of channel to be searched.
  920. Return Value:
  921.   The channel frequency (unit: 10kHz)
  922. **********************************************************************/
  923. UINT16 QND_TXClearChannelScan(UINT16 start, UINT16 stop, UINT8 step,UINT8 db)
  924. {
  925.     UINT8 regValue;
  926.     UINT16 chnFreq;
  927.     QNF_ConfigScan(start, stop, step);
  928.     QNF_SetRegBit(CCA, 0xe0, 0x20);  // set TXCCAAqn
  929.     {
  930.         QNF_SetRegBit(SYSTEM1, 0xe1, 0x60);   // &0xfe  |0x60
  931.     }
  932.     do{
  933.         QND_Delay(20);
  934.         regValue =QND_ReadReg(SYSTEM1);        
  935.     }while(regValue&0x20);
  936.     // suppose it's time to get right TX ch
  937.     chnFreq = QNF_GetCh();
  938.     QND_LOGB("BestChannel ",chnFreq);
  939.     return chnFreq;
  940. }
  941. /**********************************************************************
  942. UINT8 QND_TXSetPower( UINT8 gain)
  943. **********************************************************************
  944. Description:    Sets FM transmit power attenuation.
  945. Parameters:
  946.     gain: The transmission power attenuation value, for example,
  947.           setting the gain = 0x13, TX attenuation will be -6db
  948.           look up table see below
  949. BIT[5:4]
  950.             00    0db
  951.             01    -6db
  952.             10    -12db
  953.             11    -18db
  954. BIT[3:0]    unit: db
  955.             0000    124
  956.             0001    122.5
  957.             0010    121
  958.             0011    119.5
  959.             0100    118
  960.             0101    116.5
  961.             0110    115
  962.             0111    113.5
  963.             1000    112
  964.             1001    110.5
  965.             1010    109
  966.             1011    107.5
  967.             1100    106
  968.             1101    104.5
  969.             1110    103
  970.             1111    101.5
  971. for example:
  972.   0x2f,    //111111    89.5
  973.   0x2e,    //111110    91
  974.   0x2d,    //111101    92.5
  975.   0x2c,    //111100    94
  976.   0x1f,    //111011 95.5
  977.   0x1e,    //111010 97
  978.   0x1d,    //111001 98.5
  979.   0x1c,    //111000 100
  980.   0x0f,    //001111    101.5
  981.   0x0e,    //001110    103
  982.   0x0d,    //001101    104.5
  983.   0x0c,    //001100    106
  984.   0x0b,    //001011    107.5
  985.   0x0a,    //001010    109
  986.   0x09,    //001001    110.5
  987.   0x08,    //001000    112
  988.   0x07,    //000111    113.5
  989.   0x06,    //000110    115
  990.   0x05,    //000101    116.5
  991.   0x04,    //000100    118
  992.   0x03,    //000011    119.5
  993.   0x02,    //000010    121
  994.   0x01,    //000001    122.5
  995.   0x00     //000000    124
  996. **********************************************************************/
  997. void QND_TXSetPower( UINT8 gain)
  998. {
  999.     UINT8 value = 0;
  1000.     value |= 0x40;  
  1001.     value |= gain;
  1002.     QND_WriteReg(PAG_CAL, value);
  1003. }
  1004. /**********************************************************************
  1005. void QND_TXConfigAudio(UINT8 optiontype, UINT8 option )
  1006. **********************************************************************
  1007. Description: Config the TX audio (eg: volume,mute,etc)
  1008. Parameters:
  1009.   optiontype:option :
  1010.     QND_CONFIG_AUTOAGC:‘option'set auto AGC, 0:disable auto AGC,1:enable auto AGC.
  1011.     QND_CONFIG_SOFTCLIP;‘option’set softclip,0:disable soft clip, 1:enable softclip.
  1012.     QND_CONFIG_MONO;‘option’set mono,0: QND_AUDIO_STEREO, 1: QND_AUDIO_STEREO
  1013.     QND_CONFIG_AGCGAIN;‘option’set AGC gain, range:0000~1111
  1014. Return Value:
  1015.   none
  1016. **********************************************************************/
  1017. void QND_TXConfigAudio(UINT8 optiontype, UINT8 option )
  1018. {
  1019.     switch(optiontype)
  1020.     {
  1021.     case QND_CONFIG_MONO:
  1022.         if (option)
  1023.             QNF_SetAudioMono(0x10, QND_TX_AUDIO_MONO);
  1024.         else
  1025.             QNF_SetAudioMono(0x10, QND_TX_AUDIO_STEREO);
  1026.         break;
  1027.     case QND_CONFIG_MUTE:
  1028.         if (option)  
  1029.             QNF_SetRegBit(0x28, 0x18,0);
  1030.         else   
  1031.             QNF_SetRegBit(0x28, 0x18,0x18);
  1032.         break;
  1033.     case QND_CONFIG_SOFTCLIP:
  1034.         if (option)
  1035.             QNF_SetRegBit(TXAGC_GAIN,0x80, 0x80);
  1036.         else
  1037.             QNF_SetRegBit(TXAGC_GAIN,0x80, 0x00);
  1038.         break;
  1039.     case QND_CONFIG_AUTOAGC:
  1040.         if (option)
  1041.             QNF_SetRegBit(TXAGC_GAIN,0x40,0);
  1042.         else
  1043.             QNF_SetRegBit(TXAGC_GAIN,0x41,0x41);
  1044.         break;
  1045.     case QND_CONFIG_AGCGAIN:
  1046.         QNF_SetRegBit(TXAGC_GAIN, 0x1f,option);
  1047.         break;
  1048.     default:
  1049.         break;
  1050.     }
  1051. }
  1052. /**********************************************************************
  1053. UINT8 QND_RDSEnable(UINT8 mode)
  1054. **********************************************************************
  1055. Description: Enable or disable chip to work with RDS related functions.
  1056. Parameters:
  1057.           on: QND_RDS_ON:  Enable chip to receive/transmit RDS data.
  1058.                 QND_RDS_OFF: Disable chip to receive/transmit RDS data.
  1059. Return Value:
  1060.            QND_SUCCESS: function executed
  1061. **********************************************************************/
  1062. UINT8 QND_RDSEnable(UINT8 on)
  1063. {
  1064.     UINT8 val;
  1065.     QND_LOG("=== QND_SetRDSMode === ");
  1066.     // get last setting
  1067.     val = QND_ReadReg(SYSTEM1);
  1068.     if (on == QND_RDS_ON)
  1069.     {
  1070.         val |= RDSEN;
  1071.         // if RDS enabled, channel conditional filter is auto selected
  1072.         QNF_SetRegBit(GAIN_SEL,0x08,0x00);
  1073.     }
  1074.     else if (on == QND_RDS_OFF)
  1075.     {
  1076.         val &= ~RDSEN;
  1077.         // if RDS disabled, channel conditional filter is set to filter 2
  1078.         QNF_SetRegBit(GAIN_SEL,0x38,0x28);
  1079.     }
  1080.     else
  1081.     {
  1082.         return 0;
  1083.     }
  1084.     QND_WriteReg(SYSTEM1, val);
  1085.     return 1;
  1086. }
  1087. /**********************************************************************
  1088. UINT8 QND_DetectRDSSignal(void)
  1089. **********************************************************************
  1090. Description: detect the RDSS signal .
  1091. Parameters:
  1092.     None
  1093. Return Value:
  1094.     the value of STATUS3
  1095. **********************************************************************/
  1096. UINT8 QND_RDSDetectSignal(void)
  1097. {
  1098.     UINT8 val = QND_ReadReg(STATUS3);   
  1099.     return val;
  1100. }
  1101. /**********************************************************************
  1102. void QND_RDSLoadData(UINT8 *rdsRawData, UINT8 upload)
  1103. **********************************************************************
  1104. Description: Load (TX) or unload (RX) RDS data to on-chip RDS buffer.
  1105.              Before calling this function, always make sure to call the
  1106.              QND_RDSBufferReady function to check that the RDS is capable
  1107.              to load/unload RDS data.
  1108. Parameters:
  1109.   rdsRawData :
  1110.     8 bytes data buffer to load (on TX mode) or unload (on RXmode)
  1111.     to chip RDS buffer.
  1112.   Upload:   
  1113.     1-upload
  1114.     0--download
  1115. Return Value:
  1116.     QND_SUCCESS: rds data loaded to/from chip
  1117. **********************************************************************/
  1118. void QND_RDSLoadData(UINT8 *rdsRawData, UINT8 upload)
  1119. {
  1120.     UINT8 i;
  1121.     UINT8 temp;
  1122.     if (upload)
  1123.     {       //TX MODE
  1124.         for (i = 0; i <= 7; i++)
  1125.         {
  1126.             QND_WriteReg(RDSD0 + i, rdsRawData[i]);
  1127.         }   
  1128.     }
  1129.     else
  1130.     {
  1131.         //RX MODE
  1132.         for (i = 0; i <= 7; i++)
  1133.         {
  1134.             temp = QND_ReadReg(RDSD0 + i);
  1135.             rdsRawData[i] = temp;
  1136.         }
  1137.     }
  1138. }
  1139. /**********************************************************************
  1140. UINT8 QND_RDSCheckBufferReady(void)
  1141. **********************************************************************
  1142. Description: Check chip RDS register buffer status before doing load/unload of
  1143. RDS data.
  1144. Parameters:
  1145.     None
  1146. Return Value:
  1147.     QND_RDS_BUFFER_NOT_READY: RDS register buffer is not ready to use.
  1148.     QND_RDS_BUFFER_READY: RDS register buffer is ready to use. You can now
  1149.     load (for TX) or unload (for RX) data from/to RDS buffer
  1150. **********************************************************************/
  1151. UINT8 QND_RDSCheckBufferReady(void)
  1152. {
  1153.     UINT8 val;
  1154.     UINT8 rdsUpdated;
  1155.     rdsUpdated = QND_ReadReg(STATUS3);
  1156.     if (QND_ReadReg(SYSTEM1) & TXREQ)
  1157.     {      
  1158.         //TX MODE
  1159.         QND_WriteReg(SYSTEM2,QND_ReadReg(SYSTEM2)^RDSTXRDY);  
  1160.         return QND_RDS_BUFFER_READY;
  1161.     }
  1162.     do {
  1163.         val = QND_ReadReg(STATUS3)^rdsUpdated;      
  1164.     }while(!(val&RDS_RXUPD)) ;
  1165.     return QND_RDS_BUFFER_READY;
  1166. }
復(fù)制代碼




歡迎光臨 (http://m.raoushi.com/bbs/) Powered by Discuz! X3.1