设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › QN8027 FM发射模块和QN8027的开发资料和程序源码
返回列表 发新帖
查看: 11715|回复: 10
打印 上一主题 下一主题
收起左侧

QN8027 FM发射模块和QN8027的开发资料和程序源码

  [复制链接]
跳转到指定楼层
楼主
ID:185311 发表于 2017-4-1 11:19 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
QN8027 FM发射模块的资料和程序源码，还有QN8027开发资料

下载：
qn8006b1_sdk_driver_v1.00.rar (474.06 KB, 下载次数: 262)
QN8027.zip (1.9 MB, 下载次数: 282)







For C51

Before using this code:
- Make sure I2C address is matching datasheet
- If i2c driver existed, then just ignore qnio.c/h
- Modify QND_Deley(ms) to get accurate platform related miliseconds delay,
  otherwise all chip's functionality may not working properly
- Detail please read related doc or get FAE's help

  1. #include "qndriver.h"

  3. extern UINT8 QND_ReadReg(UINT8 adr);
  4. extern UINT8 QND_WriteReg(UINT8 adr, UINT8 value);


  7. #define R_TXRX_MASK    0xd0
  8. UINT8  S_XDATA  qnd_RSSIns = 255;
  9. UINT8  S_XDATA  qnd_Crystal = QND_CRYSTAL_DEFAULT;
  10. UINT8  S_XDATA  qnd_RSSIn[QND_BAND_NUM];
  11. UINT8  S_XDATA  qnd_PrevMode;
  12. UINT8  S_XDATA  qnd_Country  = COUNTRY_CHINA ;
  13. UINT16 S_XDATA  qnd_CH_START = 7600;
  14. UINT16 S_XDATA  qnd_CH_STOP  = 10800;
  15. UINT8  S_XDATA  qnd_CH_STEP  = 1;
  16. UINT8  qnd_ClearScanFlag = 0;
  17. UINT16 qnd_ClearChannel = 0;
  18. UINT8  qnd_FirstScan = 1;

  20. UINT8  S_XDATA qnd_AutoScanAll;
  21. UINT8  S_XDATA qnd_IsStereo;
  22. UINT8  S_XDATA qnd_ChCount;
  23. UINT16 S_XDATA  qnd_RSSInBB[QND_BAND_NUM+1];         
  24. UINT16 S_XDATA qnd_ChList[QN_CCA_MAX_CH];
  25. UINT8  S_XDATA  qnd_StepTbl[3]={5,10,20};
  26. QND_SeekCallBack qnd_CallBackFunc = 0;



  30. /**********************************************************************
  31. void QNF_RXInit()
  32. **********************************************************************
  33. Description: set to SNR based MPX control. Call this function before
  34.              tune to one specific channel

  36. Parameters:
  37. None
  38. Return Value:
  39. None
  40. **********************************************************************/
  41. void QNF_RXInit()
  42. {
  43.     QNF_SetRegBit(77,0x80,0x80);  // Set to High-Z
  44.     QNF_SetRegBit(40,0x80,0x80);  // Set SNR as criteria for MPX control

  46.     QNF_SetRegBit(64,0x3f,SMSTART_VAL); //set SMSTART
  47.     QNF_SetRegBit(66,0x3f,HCCSTART_VAL); //set HCCSTART
  48.     QNF_SetRegBit(65,0x7f,SNCSTART_VAL); //set SNCSTART
  49. }

  51. /**********************************************************************
  52. void QNF_SetMute(UINT8 On)
  53. **********************************************************************
  54. Description: set register specified bit

  56. Parameters:
  57. On:        1: mute, 0: unmute
  58. Return Value:
  59. None
  60. **********************************************************************/
  61. void QNF_SetMute(UINT8 On)
  62. {
  63.     if(On)
  64.     {
  65.         QNF_SetRegBit(REG_PD2, 0x0c, 0x0c); // mute/unmute to avoid noise   
  66.         //   QNF_SetRegBit(3, 0x80, 0x80); // mute/unmute to avoid noise   
  67.     }
  68.     else
  69.     {
  70.         QND_Delay(QND_DELAY_BEFORE_UNMUTE);
  71.         QNF_SetRegBit(REG_PD2, 0x0c, 0x00); // mute/unmute to avoid noise   
  72.         //   QND_Delay(50);
  73.      //   QNF_SetRegBit(3, 0x80, 0x00); // mute/unmute to avoid noise   
  74.     }
  75. }

  77. /**********************************************************************
  78. void QNF_SetRegBit(UINT8 reg, UINT8 bitMask, UINT8 data_val)
  79. **********************************************************************
  80. Description: set register specified bit

  82. Parameters:
  83.     reg:        register that will be set
  84.     bitMask:    mask specified bit of register
  85.     data_val:    data will be set for specified bit
  86. Return Value:
  87.     None
  88. **********************************************************************/
  89. void QNF_SetRegBit(UINT8 reg, UINT8 bitMask, UINT8 data_val)
  90. {
  91.     UINT8 temp;
  92.     temp = QND_ReadReg(reg);
  93.     temp &= (UINT8)(~bitMask);
  94.     temp |= data_val & bitMask;
  95. //    temp |= data_val;
  96.     QND_WriteReg(reg, temp);
  97. }

  99. /**********************************************************************
  100. void QNF_InitRSSInBB()
  101. **********************************************************************
  102. Description: init RSSI noise floor band

  104. Parameters:
  105.     None
  106. Return Value:
  107.     None
  108. **********************************************************************/
  109. void QNF_InitRSSInBB()
  110. {
  111.     UINT8 i,d2,d,step;
  112.     UINT16 d1;

  114.     // get frequency leap step
  115.     step = qnd_StepTbl[qnd_CH_STEP];
  116.     // total frequency span
  117.     d1 = qnd_CH_STOP - qnd_CH_START;
  118.     // make sure d2 value <= 255, normally QND_BAND_NUM should < 10
  119.     d2 = step * QND_BAND_NUM;
  120.     d = d1/d2;
  121.     // first one should be CH_START
  122.     qnd_RSSInBB[0] = qnd_CH_START;
  123.     for(i=1; i<QND_BAND_NUM; i++) {
  124.         qnd_RSSInBB[i] = qnd_RSSInBB[i-1] + d * step;
  125.     }
  126.     // last one set one more step higher for convenience
  127.     qnd_RSSInBB[i] = qnd_CH_STOP+step;
  128. }

  130. /**********************************************************************
  131. UINT8 QNF_GetRSSInBandIndex(UINT16 chfreq)
  132. **********************************************************************
  133. Description: get band index

  135. Parameters:
  136.     chfreq: channel frequency (10Khz unit, eg: for 101.10Mhz, input 10110)
  137. Return Value: band index for input CH frequency
  138. **********************************************************************/
  139. UINT8 QNF_GetRSSInBandIndex(UINT16 chfreq)  
  140. {
  141.     UINT8 i;
  142.     for(i=0; i<QND_BAND_NUM; i++) {
  143.         if(chfreq < qnd_RSSInBB[i+1]) {
  144.             // finally come to here, if no wrong input
  145.             return i;
  146.         }
  147.     }
  148. }

  150. /**********************************************************************
  151. UINT8 QNF_GetRSSIn(UINT16 chFreq)
  152. **********************************************************************
  153. Description: get RSSI noise floor

  155. Parameters:
  156.     chfreq: channel frequency (10Khz unit, eg: for 101.10Mhz, input 10110)
  157. Return Value:
  158.     the RSSI noise floor
  159. **********************************************************************/
  160. UINT8 QNF_GetRSSIn(UINT16 chFreq)
  161. {
  162.     UINT8 idx;
  163.     idx = QNF_GetRSSInBandIndex(chFreq);
  164.     return qnd_RSSIn[idx];
  165. }

  167. /**********************************************************************
  168. UINT16 QNF_GetCh()
  169. **********************************************************************
  170. Description: get current channel frequency

  172. Parameters:
  173.     None
  174. Return Value:
  175.     channel frequency
  176. **********************************************************************/
  177. UINT16 QNF_GetCh()
  178. {
  179.     UINT8 tCh;
  180.     UINT8  tStep;
  181.     UINT16 ch = 0;
  182.     // set to reg: CH_STEP
  183.     tStep = QND_ReadReg(CH_STEP);
  184.     tStep &= CH_CH;
  185.     ch  =  tStep ;
  186.     tCh= QND_ReadReg(CH);   
  187.     ch = (ch<<8)+tCh;
  188.     return CHREG2FREQ(ch);
  189. }

  191. /**********************************************************************
  192. UINT8 QNF_SetCh(UINT16 freq)
  193. **********************************************************************
  194. Description: set channel frequency

  196. Parameters:
  197.     freq:  channel frequency to be set
  198. Return Value:
  199.     1: success
  200. **********************************************************************/
  201. UINT8 QNF_SetCh(UINT16 freq)
  202. {
  203.     // calculate ch parameter used for register setting
  204.     UINT8 tStep;
  205.     UINT8 tCh;
  206.     UINT16 f;
  207.         f = FREQ2CHREG(freq);
  208.         // set to reg: CH
  209.         tCh = (UINT8) f;
  210.         QND_WriteReg(CH, tCh);
  211.         // set to reg: CH_STEP
  212.         tStep = QND_ReadReg(CH_STEP);
  213.         tStep &= ~CH_CH;
  214.         tStep |= ((UINT8) (f >> 8) & CH_CH);
  215.         QND_WriteReg(CH_STEP, tStep);

  217.     return 1;
  218. }

  220. /**********************************************************************
  221. void QNF_ConfigScan(UINT16 start,UINT16 stop, UINT8 step)
  222. **********************************************************************
  223. Description: config start, stop, step register for FM/AM CCA or CCS

  225. Parameters:
  226.     start
  227.         Set the frequency (10kHz) where scan to be started,
  228.         eg: 7600 for 76.00MHz.
  229.     stop
  230.         Set the frequency (10kHz) where scan to be stopped,
  231.         eg: 10800 for 108.00MHz
  232.     step        
  233.         1: set leap step to (FM)100kHz / 10kHz(AM)
  234.         2: set leap step to (FM)200kHz / 1kHz(AM)
  235.         0:  set leap step to (FM)50kHz / 9kHz(AM)
  236. Return Value:
  237.          None
  238. **********************************************************************/
  239. void QNF_ConfigScan(UINT16 start,UINT16 stop, UINT8 step)
  240. {
  241.     // calculate ch para
  242.     UINT8 tStep = 0;
  243.     UINT8 tS;
  244.     UINT16 fStart;
  245.     UINT16 fStop;
  246.         fStart = FREQ2CHREG(start);
  247.         fStop = FREQ2CHREG(stop);
  248.         // set to reg: CH_START
  249.     tS = (UINT8) fStart;
  250.     QND_WriteReg(CH_START, tS);
  251.     tStep |= ((UINT8) (fStart >> 6) & CH_CH_START);
  252.     // set to reg: CH_STOP
  253.     tS = (UINT8) fStop;
  254.     QND_WriteReg(CH_STOP, tS);
  255.     tStep |= ((UINT8) (fStop >> 4) & CH_CH_STOP);
  256.     // set to reg: CH_STEP
  257.     tStep |= step << 6;
  258.     QND_WriteReg(CH_STEP, tStep);
  259. }

  261. /**********************************************************************
  262. void QNF_SetAudioMono(UINT8 modemask, UINT8 mode)
  263. **********************************************************************
  264. Description:    Set audio output to mono.

  266. Parameters:
  267.   modemask: mask register specified bit
  268.   mode
  269.         QND_RX_AUDIO_MONO:    RX audio to mono
  270.         QND_RX_AUDIO_STEREO:  RX audio to stereo   
  271.         QND_TX_AUDIO_MONO:    TX audio to mono
  272.         QND_TX_AUDIO_STEREO:  TX audio to stereo
  273. Return Value:
  274.   None
  275. **********************************************************************/
  276. void QNF_SetAudioMono(UINT8 modemask, UINT8 mode)
  277. {
  278.     if (mode == QND_TX_AUDIO_MONO||mode == QND_RX_AUDIO_MONO)
  279.     {
  280.         // set to 22.5K (22.5/0.69 ~= 32)
  281.         QND_WriteReg(TX_FDEV, 0x20);
  282.     }
  283.     else
  284.     {
  285.         // back to default
  286.         QND_WriteReg(TX_FDEV, 0x6c);
  287.     }
  288.     QNF_SetRegBit(SYSTEM2,modemask, mode);
  289. }

  291. /**********************************************************************
  292. void QNF_UpdateRSSIn(UINT16 chFreq)
  293. **********************************************************************
  294. Description: update the qnd_RSSIns and qnd_RSSIn value              
  295. Parameters:
  296.     None
  297. Return Value:
  298.     None
  299. **********************************************************************/
  300. void  QNF_UpdateRSSIn(UINT16 chFreq)
  301. {
  302.     UINT8 i,j;
  303.     UINT8 r0;
  304.     UINT16 ch;

  306.     // backup SYSTEM1 register
  307.     r0 = QND_ReadReg(SYSTEM1);
  308.     if(!chFreq)
  309.     {
  310.         for (i = 0 ; i < QND_BAND_NUM; i++)
  311.         {
  312.             ch = QND_TXClearChannelScan(qnd_RSSInBB[i], qnd_RSSInBB[i+1]-qnd_StepTbl[qnd_CH_STEP], qnd_CH_STEP, 15);
  313.             qnd_RSSIn[i] = QND_GetRSSI(ch);
  314.             if (qnd_RSSIns > qnd_RSSIn[i])
  315.             {
  316.                 qnd_RSSIns = qnd_RSSIn[i];
  317.                 qnd_ClearChannel = ch;
  318.             }
  319.         }
  320.     }
  321.     else
  322.     {
  323.         i = QNF_GetRSSInBandIndex(chFreq);
  324.         ch = QND_TXClearChannelScan(qnd_RSSInBB[i], qnd_RSSInBB[i+1]-qnd_StepTbl[qnd_CH_STEP], qnd_CH_STEP, 15);
  325.         qnd_RSSIn[i] = QND_GetRSSI(ch);
  326.     }
  327.     // restore SYSTEM1 register
  328.     QND_WriteReg(SYSTEM1, r0);
  329. }

  331. /**********************************************************************
  332. int QND_Delay()
  333. **********************************************************************
  334. Description: Delay for some ms, to be customized according to user
  335.              application platform

  337. Parameters:
  338.         ms: ms counts
  339. Return Value:
  340.         None
  341.             
  342. **********************************************************************/
  343. void QND_Delay(UINT16 ms)
  344. {
  345.     UINT16 i,k;
  346.     for(i=0; i<3000;i++)
  347.     {   
  348.         for(k=0; k<ms; k++)
  349.         {

  351.         }
  352.     }
  353. }

  355. /**********************************************************************
  356. UINT8 QND_GetRSSI(UINT16 ch)
  357. **********************************************************************
  358. Description:    Get the RSSI value
  359. Parameters:
  360. Return Value:
  361. RSSI value  of the channel setted
  362. **********************************************************************/
  363. UINT8 QND_GetRSSI(UINT16 ch)
  364. {
  365.     UINT8 delayTime;
  366.     {
  367.         QND_SetSysMode(QND_MODE_RX|QND_MODE_FM);
  368.         delayTime = QND_READ_RSSI_DELAY;
  369.     }
  370.     QNF_SetCh(ch);
  371.     QNF_SetRegBit(SYSTEM1, CCA_CH_DIS, CCA_CH_DIS);   
  372.     QND_Delay(delayTime);
  373.     return QND_ReadReg(RSSISIG);  
  374. }

  376. /**********************************************************************
  377. void QN_ChipInitialization()
  378. **********************************************************************
  379. Description: chip first step initialization, called only by QND_Init()

  381. Parameters:
  382.     None
  383. Return Value:
  384.     None
  385. **********************************************************************/
  386. void QN_ChipInitialization()
  387. {
  388.     QND_WriteReg(0x01,0x89);  //sw reset
  389.     QND_WriteReg(0x50,0x00);
  390.     QND_WriteReg(0x01,0x49);  //recalibrate
  391.     QND_WriteReg(0x01,0x09);
  392.     QND_Delay(40);           //wait more than 400ms
  393.     QND_WriteReg(0x3C,0x89);  //for RDS SYNC
  394.     QNF_SetRegBit(0x49,0xc0, 0x00);
  395.     QND_WriteReg(0x4a,0xba);
  396.     QND_WriteReg(0x5c,0x05);
  397.     QND_WriteReg(0x52,0x0c);
  398.     QNF_SetRegBit(49,0x30,0x00); //minimize rxagc_timeout; WQF0717
  399.     QND_WriteReg(0x38,0x2d);  //for SNR CCA ccnclk2=2'b00
  400.     QND_WriteReg(0x39,0x88);  //for SNR CCA ccnclk1=2'b00
  401.     QND_WriteReg(0x52,0x0c);  //mute
  402.     QND_WriteReg(0x00,0x81);
  403.     QND_WriteReg(0x57,0x80);
  404.     QND_WriteReg(0x57,0x00);
  405.     QND_Delay(10);           //wait more than 100ms
  406.     QND_WriteReg(0x00,0x01);
  407.     QND_WriteReg(0x52,0x00);

  409.     QNF_SetRegBit(31,0x38,0x28);  //WQF0717
  410.     //WQF0717  
  411.     QND_WriteReg(HYSTERSIS, 0xff);
  412.     QND_WriteReg(MPSTART, 0x12);
  413.     QNF_SetRegBit(58,0xf,0xf);//set ccth11
  414. }

  416. /**********************************************************************
  417. void QND_LoadDefalutSetting(UINT8 country)
  418. **********************************************************************
  419. Description: load some defalut setting for a certain country
  420. Parameters:
  421.     country :
  422.     COUNTRY_CHINA: China
  423.     COUNTRY_USA: USA
  424.     COUNTRY_JAPAN: Japan (not supported yet)
  425. Return Value:
  426.     None
  427. **********************************************************************/
  428. void QND_LoadDefalutSetting(UINT8 country)
  429. {

  431.     switch(country)
  432.     {
  433.     case COUNTRY_CHINA:
  434.         break;
  435.     case COUNTRY_USA:
  436.         QND_ConfigFMModule(QND_CONFIG_AUDIOPEAK_DEV,75);
  437.         QND_ConfigFMModule(QND_CONFIG_PILOT_DEV,9);
  438.         QND_ConfigFMModule(QND_CONFIG_RDS_DEV,2);
  439.         QNF_SetRegBit(0x01,0x08,0x08);
  440.         QNF_SetRegBit(0x04,0x3f,0x3f);
  441.         QND_TXConfigAudio(QND_CONFIG_SOFTCLIP,1);
  442.         break;
  443.     case COUNTRY_JAPAN:
  444.         break;
  445.     default:
  446.         break;
  447.     }
  448. }

  450. /**********************************************************************
  451. int QND_Init()
  452. **********************************************************************
  453. Description: Initialize device to make it ready to have all functionality ready for use.

  455. Parameters:
  456.     None
  457. Return Value:
  458.     1: Device is ready to use.
  459.     0: Device is not ready to serve function.
  460. **********************************************************************/
  461. UINT8 QND_Init()
  462. {
  463.     QN_ChipInitialization();
  464.     QNF_SetMute(1);
  465.     QNF_InitRSSInBB();    // init band range
  466.     QND_WriteReg(0x00,  0x01); //resume original status of chip /* 2008 06 13 */
  467.     QNF_SetMute(0);
  468.     return 1;
  469. }

  471. /**********************************************************************
  472. void QND_SetSysMode(UINT16 mode)
  473. ***********************************************************************
  474. Description: Set device system mode(like: sleep ,wakeup etc)
  475. Parameters:
  476.     mode:  set the system mode , it will be set by  some macro define usually:
  477.    
  478.     SLEEP (added prefix: QND_MODE_, same as below):  set chip to sleep mode
  479.     WAKEUP: wake up chip
  480.     TX:     set chip work on TX mode
  481.     RX:     set chip work on RX mode
  482.     FM:     set chip work on FM mode
  483.     AM:     set chip work on AM mode
  484.     TX|FM:  set chip work on FM,TX mode
  485.     RX|AM;  set chip work on AM,RX mode
  486.     RX|FM:    set chip work on FM,RX mode
  487. Return Value:
  488.     None     
  489. **********************************************************************/
  490. void QND_SetSysMode(UINT16 mode)
  491. {   
  492.     UINT8 val;
  493.     switch(mode)        
  494.     {        
  495.     case QND_MODE_SLEEP:                       //set sleep mode        
  496.         qnd_PrevMode = QND_ReadReg(SYSTEM1);        
  497.         QNF_SetRegBit(SYSTEM1, R_TXRX_MASK, STNBY);         
  498.         break;        
  499.     case QND_MODE_WAKEUP:                      //set wakeup mode        
  500.         QND_WriteReg(SYSTEM1, qnd_PrevMode);        
  501.         break;        
  502.     case QND_MODE_DEFAULT:
  503.         QNF_SetRegBit(SYSTEM2,0x80,0x80);
  504.         break;
  505.     default:   
  506.             val = (UINT8)(mode >> 8);        
  507.             if (val)
  508.             {
  509.                     if(val == (QND_MODE_TX >> 8))
  510.                     {
  511.                         QND_WriteReg(73, 0x44);
  512.                     }
  513.                     else if(val == (QND_MODE_RX >> 8))
  514.                     {
  515.                         QND_WriteReg(73, 0x04);
  516.                     }                        
  517.                     // set to new mode if it's not same as old
  518.                     if((QND_ReadReg(SYSTEM1) & R_TXRX_MASK) != val)
  519.                     {
  520.                         QNF_SetMute(1);
  521.                         QNF_SetRegBit(SYSTEM1, R_TXRX_MASK, val);
  522.                         //   QNF_SetMute(0);
  523.                     }
  524.                     // make sure it's working on analog output
  525.                     QNF_SetRegBit(SYSTEM1, 0x08, 0x00);   
  526.             }   
  527.         break;        
  528.     }   
  529. }

  531. /**********************************************************************
  532. void QND_TuneToCH(UINT16 ch)
  533. **********************************************************************
  534. Description: Tune to the specific channel. call QND_SetSysMode() before
  535.     call this function
  536. Parameters:
  537.     ch
  538.     Set the frequency (10kHz) to be tuned,
  539.     eg: 101.30MHz will be set to 10130.
  540. Return Value:
  541.     None
  542. **********************************************************************/
  543. void QND_TuneToCH(UINT16 ch)
  544. {
  545.     UINT8 rssi;
  546.     UINT8 minrssi;

  548.     QNF_RXInit();

  550.     // if chip working on TX mode, just set CH
  551.     if(QND_ReadReg(SYSTEM1) & TXREQ)
  552.     {
  553.         QNF_SetRegBit(SYSTEM1, CCA_CH_DIS, CCA_CH_DIS);
  554.         QNF_SetCh(ch);   
  555.         return;
  556.     }
  557.     QNF_SetMute(1);
  558.     if ((ch - 7710) % 240 == 0)
  559.     {
  560.         QNF_SetRegBit(TXAGC_GAIN, IMR, IMR);
  561.     }
  562.     else
  563.     {
  564.         QNF_SetRegBit(TXAGC_GAIN, IMR, 0x00);
  565.     }
  566.     QNF_SetCh(ch);
  567.     QNF_SetRegBit(SYSTEM1, CCA_CH_DIS, CCA_CH_DIS);

  569.     //Free filter without RDS and Set filter 2 for Non-RDS
  570.     QNF_SetRegBit(GAIN_SEL,0x38,(QND_ReadReg(SYSTEM2) & 0x20) ? 0x00 : 0x28);
  571.     QNF_SetMute(0);
  572. }

  574. /**********************************************************************
  575. void QND_SetCountry(UINT8 country)
  576. ***********************************************************************
  577. Description: Set start, stop, step for RX and TX based on different
  578.              country
  579. Parameters:
  580. country:
  581. Set the chip used in specified country:
  582.     CHINA:
  583.     USA:
  584.     JAPAN:
  585. Return Value:
  586.     None     
  587. **********************************************************************/
  588. void QND_SetCountry(UINT8 country)
  589. {
  590.     qnd_Country = country;
  591.     switch(country)
  592.     {
  593.     case COUNTRY_CHINA:
  594.         qnd_CH_START = 7600;
  595.         qnd_CH_STOP = 10800;
  596.         qnd_CH_STEP = 1;
  597.         break;
  598.     case COUNTRY_USA:
  599.         qnd_CH_START = 8810;
  600.         qnd_CH_STOP = 10790;
  601.         qnd_CH_STEP = 2;
  602.         break;
  603.     case COUNTRY_JAPAN:
  604.         break;
  605.     }
  606. }

  608. /**********************************************************************
  609. void QND_UpdateRSSIn(UINT16 ch)
  610. **********************************************************************
  611. Description: in case of environment changed, we need to update RSSI noise floor
  612. Parameters:
  613.     None
  614. Return Value:
  615.     None
  616. **********************************************************************/
  617. void QND_UpdateRSSIn(UINT16 ch)
  618. {
  619.     UINT8 temp;
  620.     UINT8 v_abs;
  621.     if (qnd_FirstScan == 0 )
  622.     {
  623.         temp = QND_GetRSSI(qnd_ClearChannel);

  625.         if(temp > qnd_RSSIns)
  626.         {
  627.             v_abs = temp - qnd_RSSIns;
  628.         }
  629.         else
  630.         {
  631.             v_abs = qnd_RSSIns - temp;
  632.         }
  633.         if (v_abs< RSSINTHRESHOLD)
  634.         {
  635.             qnd_ClearScanFlag = 0;   
  636.         }
  637.         else
  638.         {
  639.             qnd_ClearScanFlag = 1;
  640.         }
  641.     }
  642.     if (qnd_ClearScanFlag||qnd_FirstScan||ch)
  643.     {
  644.         QNF_UpdateRSSIn(ch);
  645.         qnd_FirstScan = 0;
  646.     }
  647.     return;
  648. }

  650. /**********************************************************************
  651. void QND_ConfigFMModule(UINT8 optiontype, UINT8 option)
  652. ***********************************************************************
  653. Description: Config the FM modulation setting
  654. country
  655. Parameters:
  656.   optiontype:
  657.     QND_CONFIG_AUDIOPEAK_DEV : audio peak deviation
  658.     QND_CONFIG_PILOT_DEV:      pilot deviation
  659.     QND_CONFIG_RDS_DEV:        rds deviation  
  660.   option:
  661.     QND_CONFIG_AUDIOPEAK_DEV: 0~165khz
  662.     QND_CONFIG_PILOT_DEV:     8~10
  663.     QND_CONFIG_RDS_DEV:       1~7.5khz
  664. Return Value:
  665.     None     
  666. **********************************************************************/
  667. void QND_ConfigFMModule(UINT8 optiontype, UINT8 option)
  668. {
  669.     UINT8  tmp8;
  670.     UINT16 tmp16;
  671.     switch (optiontype)
  672.     {
  673.     case QND_CONFIG_AUDIOPEAK_DEV:
  674.         tmp16 = option*100;
  675.         tmp8  = tmp16/69;
  676.         QND_WriteReg(0x0e,tmp8);
  677.         break;
  678.     case QND_CONFIG_PILOT_DEV:
  679.         tmp8 = option<<2;
  680.         QNF_SetRegBit(0x0f,0x3c,tmp8);
  681.         break;
  682.     case QND_CONFIG_RDS_DEV:
  683.         tmp16 = option*100;
  684.         tmp8  = tmp16/35;
  685.         QNF_SetRegBit(0x18,0x7f,tmp8);
  686.         break;
  687.     default:
  688.         break;
  689.     }
  690. }

  692. /***********************************************************************
  693. Description: set call back function which can be called between seeking
  694. channel
  695. Parameters:
  696. func : the function will be called between seeking
  697. Return Value:
  698. None
  699. **********************************************************************/
  700. void QND_SetSeekCallBack(QND_SeekCallBack func)
  701. {
  702.     qnd_CallBackFunc = func;
  703. }

  705. /***********************************************************************
  706. UINT16 QND_RXSeekCH(UINT16 start, UINT16 stop, UINT16 step, UINT8 snr_th, UINT8 up);
  707. ***********************************************************************
  708. Description: Automatically scans the frequency range, and detects the
  709.                 first channel(AM or FM, it will be determine by the system mode which set
  710.                 by QND_SetSysMode).
  711.                 A threshold value needs to be passed in for channel detection.
  712. Parameters:
  713.         start
  714.                 Set the frequency (10kHz) where scan will be started,
  715.                 eg: 76.00MHz will be set to 7600.
  716.         stop
  717.                 Set the frequency (10kHz) where scan will be stopped,
  718.                 eg: 108.00MHz will be set to 10800.
  719.         step
  720.                 FM:
  721.                         QND_FMSTEP_100KHZ: set leap step to 100kHz
  722.                         QND_FMSTEP_200KHZ: set leap step to 200kHz
  723.                         QND_FMSTEP_50KHZ:  set leap step to 50kHz
  724.                 AM:
  725.                         QND_AMSTEP_***:
  726.         snr_th:
  727.                 Set threshold for quality of channel to be searched.
  728.         up:
  729.                 Set the seach direction :
  730.                         Up;0,seach from stop to start
  731.                         Up:1 seach from start to stop
  732. Return Value:
  733.   The channel frequency (unit: 10kHz)
  734.   -1: no channel found

  736. ***********************************************************************/
  737. UINT16 QND_RXSeekCH(UINT16 start, UINT16 stop, UINT8 step, UINT8 db, UINT8 up)
  738. {
  739.     UINT8 regValue;
  740.     UINT16 c, chfreq;
  741.     UINT16 ifcnt;
  742.     UINT8 savevalue;
  743.     UINT8 rssi,mprssi;
  744.     UINT8 scanFlag = 1;
  745.     UINT8 stepvalue;
  746.     UINT8 timeout = 0;
  747.     UINT8 pilot_snr;
  748.     UINT8 minrssi;
  749.     if (qnd_AutoScanAll == 0)
  750.     {
  751.         QNF_SetMute(1);
  752.         QNF_SetRegBit(GAIN_SEL,0x38,0x38);
  753.         QND_UpdateRSSIn(0);       
  754.     }
  755.     up=(start<stop) ? 1 : 0;
  756.     stepvalue = qnd_StepTbl[step];
  757.     do
  758.     {
  759.         minrssi = QNF_GetRSSIn(start);
  760.         QNF_SetCh(start);
  761.         c = start;
  762.         if ((c - 7710) % 240 == 0)
  763.         {                
  764.             QNF_SetRegBit(TXAGC_GAIN, IMR, IMR);
  765.         }
  766.         else
  767.         {
  768.             QNF_SetRegBit(TXAGC_GAIN, IMR, 0);
  769.         }       
  770.         QNF_SetRegBit(SYSTEM1,0xA1,0x81);
  771.         QND_Delay(10); //10ms delay
  772.         rssi = QND_ReadReg(RSSISIG);        //read RSSI
  773.         if (rssi > minrssi+6+db)
  774.         {       
  775.             QNF_ConfigScan(start, start, step);
  776.             QNM_SetRxThreshold(minrssi-22+db);
  777.             QNF_SetRegBit(SYSTEM1,0xA1,0xA0);
  778.             timeout = 0;
  779.             do
  780.             {
  781.                 QND_Delay(5);
  782.                 regValue = QND_ReadReg(SYSTEM1);
  783.                 timeout++;
  784.             }
  785.             while((regValue &CHSC)&&timeout < 200);
  786.             if (timeout < 200)
  787.             {
  788.                 regValue = QND_ReadReg(CCA5);
  789.                 ifcnt = regValue;
  790.                 regValue = QND_ReadReg(CCA4);
  791.                 ifcnt =(((ifcnt&0x1f)<<8)+regValue);
  792.                 if ((ifcnt < 2268) && (ifcnt > 1828))
  793.                 {
  794.                     if (rssi > minrssi + 20 + db)
  795.                     {
  796.                         scanFlag = 0;
  797.                     }
  798.                     else
  799.                     {
  800.                         QND_Delay(PILOT_READ_OUT_DELAY_TIME);
  801.                         pilot_snr = (QND_ReadReg(STATUS1) & 0x01) ? 0 : 1;   
  802.                         if (pilot_snr)
  803.                         {
  804.                             scanFlag = 0;
  805.                         }            
  806.                         else
  807.                         {
  808.                             QND_Delay(PILOT_SNR_READ_OUT_DELAY_TIME);
  809.                             pilot_snr = QND_ReadReg(SNR);  
  810.                             if (pilot_snr > 5 && pilot_snr < 55)
  811.                             {
  812.                                 scanFlag = 0;
  813.                             }
  814.                         }
  815.                     }
  816.                 }
  817.             }
  818.         }
  819.         chfreq = start;
  820.         if (scanFlag)
  821.         {
  822.             start = chfreq + (up ? stepvalue : -stepvalue);
  823.             if ((up && (stop < start)) || (!up && (start < stop)))
  824.             {
  825.                 scanFlag = 0;
  826.                 chfreq = 0;
  827.             }
  828.         }
  829.         else
  830.         {
  831.             if(qnd_CallBackFunc)
  832.                 qnd_CallBackFunc(chfreq, BAND_FM);
  833.         }
  834.     }
  835.     while (scanFlag != 0);

  837.     if (qnd_AutoScanAll == 0)
  838.     {
  839.         //Move the filter setting to TunetoChannel
  840.         //QNF_SetRegBit(32,0x08,0x08);
  841.         QND_TuneToCH((chfreq==0) ? stop: chfreq);
  842.     }
  843.     //QND_LOG("=== Done QND_AutoScan_FMChannel_One ===");
  844.     return chfreq;  
  845. }

  847. /**********************************************************************
  848. UINT8 QND_RXSeekCHAll(UINT16 start, UINT16 stop, UINT16 step, UINT8 db, UINT8 up)
  849. **********************************************************************
  850. Description:    Automatically scans the complete FM or AM band and detects
  851.             all the available  channels(AM or FM, it will be determine by
  852.             the workmode which set by QND_SetSysmode). A threshold value
  853.             needs to be passed in for the channel detection.
  854. Parameters:
  855.     start
  856.         Set the frequency (10kHz) where scan will be started,
  857.         eg: 76.00MHz will be set to 7600.
  858.     stop
  859.         Set the frequency (10kHz) where scan will be stopped,
  860.         eg: 108.00MHz will be set to 10800.
  861.     Step
  862.         FM:
  863.             QND_FMSTEP_100KHZ: set leap step to 100kHz
  864.             QND_FMSTEP_200KHZ: set leap step to 200kHz
  865.             QND_FMSTEP_50KHZ:  set leap step to 50kHz
  866.         AM:
  867.         QND_AMSTEP_***:
  868.     db
  869.         Set signal noise ratio for channel to be searched.
  870.     up:
  871.         Set the seach direction :
  872.         Up;0,seach from stop to start
  873.         Up:1 seach from start to stop

  875. Return Value:
  876.   The channel count found by this function
  877.   -1: no channel found
  878. **********************************************************************/
  879. UINT8 QND_RXSeekCHAll(UINT16 start, UINT16 stop, UINT8 step, UINT8 db, UINT8 up)
  880. {
  881.     UINT16 prevCh = 0;
  882.     //UINT16 chfreq;
  883.     UINT8  stepvalue;
  884.     UINT16 temp;
  885.     UINT16 pStart = start;
  886.     UINT16 pStop = stop > qnd_CH_STOP ? qnd_CH_STOP : stop;
  887.     QNF_SetMute(1);
  888.     up=(start<stop) ? 1 : 0;
  889.     qnd_AutoScanAll = 1;
  890.     stepvalue = qnd_StepTbl[step];
  891.     QNF_SetRegBit(GAIN_SEL,0x38,0x38);
  892.     {
  893.         QND_UpdateRSSIn(0);
  894.     }
  895.     qnd_ChCount = 0;
  896.     do
  897.     {  
  898.         temp = QND_RXSeekCH(pStart, pStop, step, db, up);
  899.         if (temp)
  900.         {
  901.             qnd_ChList[qnd_ChCount++] =temp;
  902.         }
  903.         else
  904.         {
  905.             temp = pStop;
  906.         }
  907.         {
  908.             pStart = temp + (up ? stepvalue : -stepvalue);
  909.         }
  910.     }
  911.     while((up ? (pStart<=pStop):(pStart>=pStop)) && (qnd_ChCount < QN_CCA_MAX_CH));

  913.     QND_TuneToCH((qnd_ChCount >= 1)? qnd_ChList[0] : pStop);
  914.     qnd_AutoScanAll = 0;
  915.     QNF_SetMute(0);
  916.     return qnd_ChCount;
  917. }

  919. /************************************************************************
  920. void QND_RXConfigAudio(UINT8 optiontype, UINT8 option )
  921. *************************************************************************
  922. Description: config audio
  923. Parameters:
  924.   optiontype: option
  925.     QND_CONFIG_MUTE; ‘option’control muteable, 0:mutedisable,1:mute enable
  926.     QND_CONFIG_MONO; ‘option’control mono, 0: QND_AUDIO_STEREO,1: QND_AUDIO_STEREO
  927.     QND_CONFIG_EQUALIZER: 'option' control the EQUALIZER,0:disable  EQUALIZER; 1: enable EQUALIZER;
  928.     QND_CONFIG_VOLUME: 'option' control the volume gain,range : 0~83(0: -65db, 65: 0db, 83: +18db
  929.     QND_CONFIG_BASS_QUALITY: 'option' set BASS quality factor,0: 1, 1: 1.25, 2: 1.5, 3: 2
  930.     QND_CONFIG_BASS_FREQ: 'option' set BASS central frequency,0: 60Hz, 1: 70Hz, 2: 80Hz, 3: 100Hz
  931.     QND_CONFIG_BASS_GAIN: 'option' set BASS control gain,range : 0x0~0x1e (00000 :-15db, 11110 :15db
  932.     QND_CONFIG_MID_QUALITY: 'option' set MID quality factor,0 :1, 1 :2
  933.     QND_CONFIG_MID_FREQ: 'option' set MID central frequency,0: 0.5KHz, 1: 1KHz, 2: 1.5KHz, 3: 2KHz
  934.     QND_CONFIG_MID_GAIN: 'option' set MID control gain,range : 0x0~0x1e (00000 :-15db, 11110 :15db)
  935.     QND_CONFIG_TREBLE_FREQ: 'option' set TREBLE central frequency,0: 10KHz, 1: 12.5KHz, 2: 15KHz, 3: 17.5KHz
  936.     QND_CONFIG_TREBLE_GAIN: 'option' set TREBLE control gain,range : 0x0~0x1e (00000 :-15db, 11110 :15db

  938. Return Value:
  939.     none
  940. **********************************************************************/
  941. void QND_RXConfigAudio(UINT8 optiontype, UINT8 option )
  942. {
  943.     switch(optiontype)
  944.     {
  945.     case QND_CONFIG_MONO:
  946.         if (option)
  947.             QNF_SetAudioMono(RX_MONO_MASK, QND_RX_AUDIO_MONO);
  948.         else
  949.             QNF_SetAudioMono(RX_MONO_MASK, QND_RX_AUDIO_STEREO);
  950.         break;
  951.     case QND_CONFIG_MUTE:
  952.         if (option)
  953.             QNF_SetMute(1);
  954.         else
  955.             QNF_SetMute(0);
  956.         break;

  958.     default:
  959.         break;
  960.     }
  961. }

  963. /**********************************************************************
  964. UINT16 QND_TXClearChannelScan(UINT16 start, UINT16 stop, UINT16 step,UINT8 db)
  965. **********************************************************************
  966. Description:    Clean channel scan. Finds the best clear channel for transmission.

  968. Parameters:
  969.   Start
  970.     Set the frequency (10kHz) where scan will be started,
  971.     eg: 7600 for 76.00MHz
  972.   Stop
  973.     Set the frequency (10kHz) where scan will be stopped,
  974.     eg: 10800 for 108.00MHz
  975.   Step
  976.     QND_FSTEP_100KHZ: Set leap step to 100kHz.
  977.     QND_FSTEP_200KHZ: Set leap step to 200kHz.
  978.     QND_FSTEP_50KHZ:  Set leap step to 50kHz.
  979.   db
  980.     Set threshold for quality of channel to be searched.
  981. Return Value:
  982.   The channel frequency (unit: 10kHz)
  983. **********************************************************************/
  984. UINT16 QND_TXClearChannelScan(UINT16 start, UINT16 stop, UINT8 step,UINT8 db)
  985. {
  986.     UINT8 regValue;
  987.     UINT16 chnFreq;
  988.     QNF_ConfigScan(start, stop, step);
  989.     QNF_SetRegBit(CCA, 0xe0, 0x20);  // set TXCCAAqn
  990.     {
  991.         QNF_SetRegBit(SYSTEM1, 0xe1, 0x60);   // &0xfe  |0x60
  992.     }
  993.     do{
  994.         QND_Delay(20);
  995.         regValue =QND_ReadReg(SYSTEM1);        
  996.     }while(regValue&0x20);
  997.     // suppose it's time to get right TX ch
  998.     chnFreq = QNF_GetCh();
  999.     QND_LOGB("BestChannel ",chnFreq);
  1000.     return chnFreq;
  1001. }

  1003. /**********************************************************************
  1004. UINT8 QND_TXSetPower( UINT8 gain)
  1005. **********************************************************************
  1006. Description:    Sets FM transmit power attenuation.

  1008. Parameters:
  1009.     gain: The transmission power attenuation value, for example,
  1010.           setting the gain = 0x13, TX attenuation will be -6db
  1011.           look up table see below
  1012. BIT[5:4]
  1013.             00    0db
  1014.             01    -6db
  1015.             10    -12db
  1016.             11    -18db
  1017. BIT[3:0]    unit: db
  1018.             0000    124
  1019.             0001    122.5
  1020.             0010    121
  1021.             0011    119.5
  1022.             0100    118
  1023.             0101    116.5
  1024.             0110    115
  1025.             0111    113.5
  1026.             1000    112
  1027.             1001    110.5
  1028.             1010    109
  1029.             1011    107.5
  1030.             1100    106
  1031.             1101    104.5
  1032.             1110    103
  1033.             1111    101.5
  1034. for example:
  1035.   0x2f,    //111111    89.5
  1036.   0x2e,    //111110    91
  1037.   0x2d,    //111101    92.5
  1038.   0x2c,    //111100    94
  1039.   0x1f,    //111011 95.5
  1040.   0x1e,    //111010 97
  1041.   0x1d,    //111001 98.5
  1042.   0x1c,    //111000 100
  1043.   0x0f,    //001111    101.5
  1044.   0x0e,    //001110    103
  1045.   0x0d,    //001101    104.5
  1046.   0x0c,    //001100    106
  1047.   0x0b,    //001011    107.5
  1048.   0x0a,    //001010    109
  1049.   0x09,    //001001    110.5
  1050.   0x08,    //001000    112
  1051.   0x07,    //000111    113.5
  1052.   0x06,    //000110    115
  1053.   0x05,    //000101    116.5
  1054.   0x04,    //000100    118
  1055.   0x03,    //000011    119.5
  1056.   0x02,    //000010    121
  1057.   0x01,    //000001    122.5
  1058.   0x00     //000000    124
  1059. **********************************************************************/
  1060. void QND_TXSetPower( UINT8 gain)
  1061. {
  1062.     UINT8 value = 0;
  1063.     value |= 0x40;  
  1064.     value |= gain;
  1065.     QND_WriteReg(PAG_CAL, value);
  1066. }

  1068. /**********************************************************************
  1069. void QND_TXConfigAudio(UINT8 optiontype, UINT8 option )
  1070. **********************************************************************
  1071. Description: Config the TX audio (eg: volume,mute,etc)
  1072. Parameters:
  1073.   optiontype:option :
  1074.     QND_CONFIG_AUTOAGC:‘option'set auto AGC, 0:disable auto AGC,1:enable auto AGC.
  1075.     QND_CONFIG_SOFTCLIP;‘option’set softclip,0:disable soft clip, 1:enable softclip.
  1076.     QND_CONFIG_MONO;‘option’set mono,0: QND_AUDIO_STEREO, 1: QND_AUDIO_STEREO
  1077.     QND_CONFIG_AGCGAIN;‘option’set AGC gain, range:0000~1111
  1078. Return Value:
  1079.   none
  1080. **********************************************************************/
  1081. void QND_TXConfigAudio(UINT8 optiontype, UINT8 option )
  1082. {
  1083.     switch(optiontype)
  1084.     {
  1085.     case QND_CONFIG_MONO:
  1086.         if (option)
  1087.             QNF_SetAudioMono(0x10, QND_TX_AUDIO_MONO);
  1088.         else
  1089.             QNF_SetAudioMono(0x10, QND_TX_AUDIO_STEREO);
  1090.         break;

  1092.     case QND_CONFIG_MUTE:
  1093.         if (option)  
  1094.             QNF_SetRegBit(0x28, 0x18,0);
  1095.         else   
  1096.             QNF_SetRegBit(0x28, 0x18,0x18);
  1097.         break;
  1098.     case QND_CONFIG_SOFTCLIP:
  1099.         if (option)
  1100.             QNF_SetRegBit(TXAGC_GAIN,0x80, 0x80);
  1101.         else
  1102.             QNF_SetRegBit(TXAGC_GAIN,0x80, 0x00);
  1103.         break;

  1105.     case QND_CONFIG_AUTOAGC:
  1106.         if (option)
  1107.             QNF_SetRegBit(TXAGC_GAIN,0x40,0);
  1108.         else
  1109.             QNF_SetRegBit(TXAGC_GAIN,0x41,0x41);
  1110.         break;
  1111.     case QND_CONFIG_AGCGAIN:
  1112.         QNF_SetRegBit(TXAGC_GAIN, 0x1f,option);
  1113.         break;
  1114.     default:
  1115.         break;
  1116.     }
  1117. }

  1119. /**********************************************************************
  1120. UINT8 QND_RDSEnable(UINT8 mode)
  1121. **********************************************************************
  1122. Description: Enable or disable chip to work with RDS related functions.
  1123. Parameters:
  1124.           on: QND_RDS_ON:  Enable chip to receive/transmit RDS data.
  1125.                 QND_RDS_OFF: Disable chip to receive/transmit RDS data.
  1126. Return Value:
  1127.            QND_SUCCESS: function executed
  1128. **********************************************************************/
  1129. UINT8 QND_RDSEnable(UINT8 on)
  1130. {
  1131.     UINT8 val;

  1133.     QND_LOG("=== QND_SetRDSMode === ");
  1134.     // get last setting
  1135.     val = QND_ReadReg(SYSTEM1);
  1136.     if (on == QND_RDS_ON)
  1137.     {
  1138.         val |= RDSEN;
  1139.         // if RDS enabled, channel conditional filter is auto selected
  1140.         QNF_SetRegBit(GAIN_SEL,0x08,0x00);
  1141.     }
  1142.     else if (on == QND_RDS_OFF)
  1143.     {
  1144.         val &= ~RDSEN;
  1145.         // if RDS disabled, channel conditional filter is set to filter 2
  1146.         QNF_SetRegBit(GAIN_SEL,0x38,0x28);
  1147.     }
  1148.     else
  1149.     {
  1150.         return 0;
  1151.     }
  1152.     QND_WriteReg(SYSTEM1, val);
  1153.     return 1;
  1154. }

  1156. /**********************************************************************
  1157. UINT8 QND_DetectRDSSignal(void)
  1158. **********************************************************************
  1159. Description: detect the RDSS signal .

  1161. Parameters:
  1162.     None
  1163. Return Value:
  1164.     the value of STATUS3
  1165. **********************************************************************/
  1166. UINT8 QND_RDSDetectSignal(void)
  1167. {
  1168.     UINT8 val = QND_ReadReg(STATUS3);   
  1169.     return val;
  1170. }

  1172. /**********************************************************************
  1173. void QND_RDSLoadData(UINT8 *rdsRawData, UINT8 upload)
  1174. **********************************************************************
  1175. Description: Load (TX) or unload (RX) RDS data to on-chip RDS buffer.
  1176.              Before calling this function, always make sure to call the
  1177.              QND_RDSBufferReady function to check that the RDS is capable
  1178.              to load/unload RDS data.
  1179. Parameters:
  1180.   rdsRawData :
  1181.     8 bytes data buffer to load (on TX mode) or unload (on RXmode)
  1182.     to chip RDS buffer.
  1183.   Upload:   
  1184.     1-upload
  1185.     0--download
  1186. Return Value:
  1187.     QND_SUCCESS: rds data loaded to/from chip
  1188. **********************************************************************/
  1189. void QND_RDSLoadData(UINT8 *rdsRawData, UINT8 upload)
  1190. {
  1191.     UINT8 i;
  1192.     UINT8 temp;
  1193.     if (upload)
  1194.     {       //TX MODE
  1195.         for (i = 0; i <= 7; i++)
  1196.         {
  1197.             QND_WriteReg(RDSD0 + i, rdsRawData[i]);
  1198.         }   
  1199.     }
  1200.     else
  1201.     {
  1202.         //RX MODE
  1203.         for (i = 0; i <= 7; i++)
  1204.         {
  1205.             temp = QND_ReadReg(RDSD0 + i);
  1206.             rdsRawData[i] = temp;
  1207.         }
  1208.     }
  1209. }

  1211. /**********************************************************************
  1212. UINT8 QND_RDSCheckBufferReady(void)
  1213. **********************************************************************
  1214. Description: Check chip RDS register buffer status before doing load/unload of
  1215. RDS data.

  1217. Parameters:
  1218.     None
  1219. Return Value:
  1220.     QND_RDS_BUFFER_NOT_READY: RDS register buffer is not ready to use.
  1221.     QND_RDS_BUFFER_READY: RDS register buffer is ready to use. You can now
  1222.     load (for TX) or unload (for RX) data from/to RDS buffer
  1223. **********************************************************************/
  1224. UINT8 QND_RDSCheckBufferReady(void)
  1225. {
  1226.     UINT8 val;
  1227.     UINT8 rdsUpdated;
  1228.     rdsUpdated = QND_ReadReg(STATUS3);
  1229.     if (QND_ReadReg(SYSTEM1) & TXREQ)
  1230.     {      
  1231.         //TX MODE
  1232.         QND_WriteReg(SYSTEM2,QND_ReadReg(SYSTEM2)^RDSTXRDY);  
  1233.         return QND_RDS_BUFFER_READY;
  1234.     }
  1235.     do {
  1236.         val = QND_ReadReg(STATUS3)^rdsUpdated;      
  1237.     }while(!(val&RDS_RXUPD)) ;
  1238.     return QND_RDS_BUFFER_READY;
  1239. }

复制代码


程序, 资料
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏4 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:79034 发表于 2017-5-23 19:08 | 只看该作者
楼主有没51现成试过能用的例程啊？新手。这个不知道怎么改啊。
回复

使用道具 举报

板凳
ID:228360 发表于 2017-10-30 11:10 | 只看该作者
很不错，谢谢分享。
回复

使用道具 举报

地板
ID:338360 发表于 2018-8-31 15:36 | 只看该作者
不错不错，谢谢分享
回复

使用道具 举报

5#
ID:338360 发表于 2018-9-3 08:40 | 只看该作者
下来参考一下，刚有项目要用8027
回复

使用道具 举报

6#
ID:44267 发表于 2018-10-24 19:31 | 只看该作者
请问楼主这个有实物成功了嘛
回复

使用道具 举报

7#
ID:28367 发表于 2019-3-1 10:06 | 只看该作者
很详细，谢谢楼主分享
回复

使用道具 举报

8#
ID:535790 发表于 2020-3-19 22:15 | 只看该作者
学习一下
回复

使用道具 举报

9#
ID:568565 发表于 2020-5-9 15:16 | 只看该作者
51的驱动放进去以后空间都不够用了
回复

使用道具 举报

10#
ID:334128 发表于 2023-6-23 21:31 | 只看该作者
正在找此芯片资料，谢谢！
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表