21ic电子技术开发论坛 › 单片机与嵌入式系统 › Microchip › PIC18F2520驱动RDA5807方案
返回列表 发新帖我要提问

[PIC®/AVR®/dsPIC®产品] PIC18F2520驱动RDA5807方案

[复制链接]
 楼主| 玛尼玛尼哄 发表于 2024-9-27 22:44 | 显示全部楼层 |阅读模式
pi, ic, RDA5807, PIC18F, PIC18
游客，如果您要查看本帖隐藏内容请回复

是一个非常简单的固件，用于控制RDA5807 I2C 无线电 ic。
  • 2x16 LCD 显示屏。
  • 存储 6 个内存位置。
  • RDS 就绪。
  • 音量控制。




复制
  1. /*
    

  2.     File:   main.c
    

  3.     Copyright 2016 Marcos Mori de Siqueira <mori.br@gmail.com>
    


  4. 

  5.     Licensed under the Apache License, Version 2.0 (the "License");
    

  6.     you may not use this file except in compliance with the License.
    

  7.     You may obtain a copy of the License at
    


  8. 

  9.        http://www.apache.org/licenses/LICENSE-2.0
    


  10. 

  11.     Unless required by applicable law or agreed to in writing, software
    

  12.     distributed under the License is distributed on an "AS IS" BASIS,
    

  13.     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    

  14.     See the License for the specific language governing permissions and
    

  15.     limitations under the License.
    

  16. */
    

  17. //#include <p18cxxx.h>
    

  18. #include <p18f2520.h>
    

  19. #include <delays.h>
    

  20. #include <usart.h>
    

  21. #include <stdio.h>
    

  22. #include <stdlib.h>
    

  23. #include <string.h>
    

  24. #include <i2c.h>
    

  25. #include <timers.h>
    

  26. #include "rda5807.h"
    

  27. #include "hardwareprofile.h"
    

  28. #include "LCDBlocking.h"
    

  29. #include "TimeDelay.h"
    

  30. #include "keypad.h"
    

  31. #include "log.h"
    

  32. #include "eeprom.h"
    

  33. #include "rds.h"
    

  34. #include "options.h"
    

  35. #include "test.h"
    

  36. #include <math.h>
    


  37. 

  38. #pragma config OSC    = HS
    

  39. #pragma config WDT    = OFF
    

  40. #pragma config LVP    = OFF
    

  41. #pragma config MCLRE  = ON
    

  42. #pragma config PWRT   = ON
    

  43. #pragma config PBADEN = OFF
    


  44. 

  45. #define MAX_VOLUME          0x0C    //0x0F
    


  46. 

  47. #define SAVE_TIMEOUT        5000
    

  48. #define BACK2IDLE_TIMEOUT   1000
    

  49. #define MENU_TIMEOUT        50000
    


  50. 

  51. #define STATE_IDLE          0
    

  52. #define STATE_VOLUME        1
    

  53. #define STATE_MEMORY        2
    

  54. #define STATE_MENU          3
    

  55. #define STATE_LAST_BASIC    3
    

  56. #define STATE_LAST          4
    


  57. 

  58. static BYTE mem_idx = 0;
    

  59. static BYTE state = STATE_IDLE;
    

  60. static LONG state_timeout = 0;
    


  61. 

  62. extern volatile RDSINFO rds;
    

  63. static RDAINFO info;
    


  64. 

  65. typedef struct 
    

  66. {
    

  67.     RDA_MEMORY mem;
    

  68.     LONG mem_save_timeout;
    

  69.     BYTE enabled;
    

  70.     
    

  71. } SAVEINFO;
    


  72. 

  73. static SAVEINFO save_info = {{0},0,0};
    


  74. 

  75. static void update_lcd(void);
    

  76. static void process_dn(void);
    

  77. static void process_up(void);
    

  78. static BYTE setup_memory(void);
    


  79. 

  80. void main(void)
    

  81. {   
    

  82.     char *c = 0;
    

  83.     DWORD counter = 0, read = 0;
    

  84.     BYTE  evt;
    

  85.     DWORD ellapsed = 0;
    

  86.     BYTE  btn_ok_pressed = 0;
    

  87.     
    

  88.     CMCON   = 0x07; // Comparators Off
    

  89.     CVRCON  = 0;    // voltage reference=off
    

  90.     ADCON1  = 0x0F; // Disable ALL adc channels, PDF page 226
    

  91.     
    

  92.     LED1_TRIS    = OUTPUT_PIN;
    

  93.         I2C_SCL_TRIS = OUTPUT_PIN;
    

  94.         I2C_SDA_TRIS = OUTPUT_PIN;
    

  95.     
    

  96.     // Uart
    

  97.     OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 10);
    


  98. 

  99.     LOG((ROMCHAR)"\r\n-------------------------------------------------\r\n");
    

  100.     
    

  101.     KeypadInit();
    

  102.     
    

  103.     LCDInit();
    

  104.   
    

  105.     // Setup I2C
    

  106.     OpenI2C(MASTER, SLEW_OFF);
    

  107.     //SSPADD = 0x32; //100kHz Baud clock @20MHz
    

  108.     SSPADD = 0x0B;//400kHz Baud clock @20MHz
    

  109.     
    

  110.     LCDErase();
    

  111.     strcpypgm2ram(c, (ROMCHAR)"    STARTING    ");
    

  112.     LCDWriteLine(1, c);
    

  113.     
    

  114.     memset(save_info.mem.data, 0, sizeof(RDA_MEMORY));
    


  115. 

  116. //TEST_eeprom_reset(); 
    


  117. 

  118.     if(!EEPROM_load_data(&save_info.mem))
    

  119.     {
    

  120. LOG((ROMCHAR)"loading default config\r\n");
    

  121.         save_info.mem.flags   = RDA_FLAG_RDS|RDA_FLAG_BASS;
    

  122.         save_info.mem.channel = 101.7;
    

  123.         save_info.mem.volume  = 1;
    


  124. 

  125. //save_info.mem.memory[0] = 97.7;
    

  126. //save_info.mem.memory[3] = 103.3;
    

  127. //save_info.mem.memory[4] = 90.5;
    

  128.     }
    

  129.     
    

  130.     LOG((ROMCHAR)"init\r\n");    
    

  131.     RDA5807M_init();
    


  132. 

  133.     RDA5807M_PowerON();
    

  134.     
    

  135.     DelayMs(200);
    


  136. 

  137.     // Setup radio
    

  138.     RDA5807M_SetVolume(save_info.mem.volume); 
    

  139.     RDA5807M_SetFrequency(save_info.mem.channel);
    

  140.     RDA5807M_BassBoost(save_info.mem.flags & RDA_FLAG_BASS);
    

  141.     RDA5807M_Mono(save_info.mem.flags & RDA_FLAG_MONO);
    

  142.     RDA5807M_RDS(save_info.mem.flags & RDA_FLAG_RDS);
    

  143.     
    

  144.         while(1)
    

  145.         {
    

  146.         LED1 = 0;
    

  147.         if(counter++ > 3000)
    

  148.         {
    

  149.             counter = 0;
    

  150.             LED1 = 1;
    

  151.             DelayMs(10);
    

  152.         }
    


  153. 

  154.         evt = GetButtonsEvents();
    

  155.              if(evt != EVENT_NOTHING)
    

  156.               {
    

  157.                         if(evt == EVENT_UP_BUTTON_PUSHED)
    

  158.                         {
    

  159.                 if(state != STATE_MENU)
    

  160.                 {
    

  161. //LOG((ROMCHAR)"up %d\r\n", state);                    
    

  162.                     if(++state >= STATE_LAST_BASIC)
    

  163.                         state = STATE_IDLE;
    

  164. //LOG((ROMCHAR)"up %d\r\n", state);
    

  165.                     
    

  166.                     if(state == STATE_MEMORY)
    

  167.                         mem_idx = setup_memory();
    

  168.                     
    

  169.                     if(state > STATE_IDLE)
    

  170.                         state_timeout = BACK2IDLE_TIMEOUT;
    

  171.                     else 
    

  172.                     {
    

  173.                         state_timeout = 0;
    

  174.                         rds.ps_valid = 1;
    

  175.                         rds.rt_valid = 1;
    

  176.                     }
    

  177.                 }
    

  178.                 else
    

  179.                 {
    

  180.                     state_timeout = MENU_TIMEOUT;
    

  181.                     MENU_run(MENU_UP);
    

  182.                 }
    

  183.                         }
    

  184.                         else if(evt == EVENT_DN_BUTTON_PUSHED)
    

  185.                         {
    

  186.                 if(state != STATE_MENU)
    

  187.                 {
    

  188. //LOG((ROMCHAR)"dn %d\r\n", state);                    
    

  189.                     if(--state >= 0xFF)
    

  190.                         state = STATE_IDLE;
    

  191. //LOG((ROMCHAR)"dn %d\r\n", state);
    

  192.                     if(state > STATE_IDLE)
    

  193.                         state_timeout = BACK2IDLE_TIMEOUT;
    

  194.                     else 
    

  195.                     {
    

  196.                         state_timeout = 0;
    

  197.                         rds.ps_valid = 1;
    

  198.                         rds.rt_valid = 1;
    

  199.                     }
    

  200.                 }
    

  201.                 else
    

  202.                 {
    

  203.                     state_timeout = MENU_TIMEOUT;
    

  204.                     MENU_run(MENU_DOWN);
    

  205.                 }
    

  206.                         }
    

  207.                         else if(evt == EVENT_LEFT_BUTTON_PUSHED)
    

  208.                         {
    

  209.                 //LOG((ROMCHAR)"left\r\n");
    

  210.                 if(state == STATE_MENU)
    

  211.                 {
    

  212.                     state_timeout = MENU_TIMEOUT;
    

  213.                     MENU_run(MENU_LEFT);
    

  214.                 }
    

  215.                 else
    

  216.                     process_dn();
    

  217.                         }   
    

  218.                         else if(evt == EVENT_RIGHT_BUTTON_PUSHED)
    

  219.                         {
    

  220.                 //LOG((ROMCHAR)"right\r\n");
    

  221.                 if(state == STATE_MENU)
    

  222.                 {
    

  223.                     state_timeout = MENU_TIMEOUT;
    

  224.                     MENU_run(MENU_RIGHT);
    

  225.                 }
    

  226.                 else                
    

  227.                     process_up();
    

  228.                         }   
    

  229.             else if(evt == EVENT_OK_BUTTON_PUSHED)
    

  230.                         {
    

  231.                 btn_ok_pressed = 1;
    

  232.                 ellapsed = 0;
    

  233.                         }   
    

  234.             else if(evt == EVENT_MENU_BUTTON_PUSHED)
    

  235.                         {
    

  236.                 LOG((ROMCHAR)"menu\r\n");
    


  237. 

  238.                 if(state == STATE_MENU)
    

  239.                     state_timeout = 1;  // change to idle
    

  240.                 else
    

  241.                 {
    

  242.                     MENU_init(&save_info.mem);
    

  243.                     state = STATE_MENU;
    

  244.                     state_timeout = MENU_TIMEOUT;
    

  245.                 }
    

  246.                         }
    

  247.             else if(evt == EVENT_OK_BUTTON_RELEASED)
    

  248.             {
    

  249. LOG((ROMCHAR)"OK released\r\n");
    

  250.                 btn_ok_pressed = 0;
    

  251.                 if(ellapsed < 250) 
    

  252.                 {
    

  253.                     if(state == STATE_MENU)
    

  254.                     {
    

  255.                         if(MENU_run(MENU_OK)) 
    

  256.                         {
    

  257.                             save_info.enabled = 1;
    

  258.                             state_timeout = 400;
    

  259.                         }
    

  260.                         else
    

  261.                             state_timeout = MENU_TIMEOUT;
    

  262.                     }
    

  263.                     else                
    

  264.                     {
    

  265.                         switch(state)
    

  266.                         {
    

  267.                             case STATE_IDLE:
    

  268.                                 RDA5807M_Mute();
    

  269.                                 break;
    


  270. 

  271.                             case STATE_MEMORY:
    

  272.                                 if(save_info.mem.memory[mem_idx] > 0)
    

  273.                                 {
    

  274.                                     RDA5807M_SetFrequency(save_info.mem.memory[mem_idx]);
    

  275.                                     state_timeout = 1;  // change to idle
    

  276.                                 }
    

  277.                                 break;
    

  278.                         }
    

  279.                     }
    

  280.                 }
    

  281.             }
    

  282.                 } 
    

  283.         
    

  284.         if(read++ > 1)
    

  285.         {
    

  286.             read = 0;
    

  287.             RDA5807M_Read(&info);
    

  288.             update_lcd();
    

  289.         }
    

  290.         
    

  291.         if(save_info.mem_save_timeout > 0)
    

  292.         {
    

  293.             if(--save_info.mem_save_timeout <= 0)
    

  294.             {
    

  295.                 save_info.mem_save_timeout = 0;
    

  296. LOG((ROMCHAR)"SAVE DATA EEPROM\r\n");                      
    


  297. 

  298. LOG((ROMCHAR)"chann %d\r\n", (int)save_info.mem.channel);
    


  299. 

  300.             EEPROM_save_data(&save_info.mem);
    

  301.             }
    

  302.         }
    

  303.         
    

  304.         // Dont back to IDLE while pressing memory saving button
    

  305.         if(!btn_ok_pressed && state_timeout > 0)
    

  306.         {
    

  307.             if(--state_timeout <= 0)
    

  308.             {
    

  309. LOG((ROMCHAR)"IDLE\r\n");                
    

  310.                 state_timeout = 0;
    

  311.                 rds.ps_valid = 1;
    

  312.                 rds.rt_valid = 1;
    

  313.                 state = STATE_IDLE;
    

  314.             }
    

  315.         }
    

  316.         
    

  317.         ellapsed++;
    

  318.         if(btn_ok_pressed && ellapsed > 250)
    

  319.         {
    

  320.             save_info.mem.memory[mem_idx] = save_info.mem.channel;
    

  321.             state_timeout = 1;
    

  322.         }
    

  323.         }
    

  324. }
    


  325. 

  326. static void process_up(void)
    

  327. {
    

  328.     switch(state)
    

  329.     {
    

  330.         case STATE_IDLE:
    

  331.             save_info.enabled = 1;
    

  332.             RDA5807M_SeekUp();
    

  333.             break;
    

  334.     
    

  335.         case STATE_VOLUME:
    

  336.             if(++save_info.mem.volume >= MAX_VOLUME)
    

  337.                 save_info.mem.volume = MAX_VOLUME;
    

  338.             state_timeout = BACK2IDLE_TIMEOUT;
    

  339.             RDA5807M_SetVolume(save_info.mem.volume); 
    

  340.             break;
    

  341.             
    

  342.         case STATE_MEMORY:
    

  343.             if(++mem_idx >= MAX_CHANNEL_MEM)
    

  344.                 mem_idx = MAX_CHANNEL_MEM-1;
    

  345.             state_timeout = BACK2IDLE_TIMEOUT;
    

  346.             break;
    

  347.     }
    

  348. }
    


  349. 

  350. static void process_dn(void)
    

  351. {
    

  352.     switch(state)
    

  353.     {
    

  354.         case STATE_IDLE:    
    

  355.             save_info.enabled = 1;
    

  356.             RDA5807M_SeekDown();
    

  357.             break;
    

  358.             
    

  359.         case STATE_VOLUME:
    

  360.             if(--save_info.mem.volume >= 0xFF)
    

  361.                 save_info.mem.volume = 0;
    

  362.             state_timeout = BACK2IDLE_TIMEOUT;
    

  363.             RDA5807M_SetVolume(save_info.mem.volume); 
    

  364.             break;
    

  365.             
    

  366.         case STATE_MEMORY:
    

  367.             if(--mem_idx >= 0xFF)
    

  368.                 mem_idx = 0;
    

  369.             state_timeout = BACK2IDLE_TIMEOUT;
    

  370.             break;
    

  371.     }
    

  372. }
    


  373. 

  374. static void update_volume(void)
    

  375. {
    

  376.     BYTE i = 0;
    

  377.     
    

  378.     strcpypgm2ram(LCDText[1], (ROMCHAR)"VOL ");
    

  379.     for(; i < save_info.mem.volume; ++i)
    

  380.         strcatpgm2ram(LCDText[1], (ROMCHAR)"\xFF");
    

  381. }
    


  382. 

  383. static BYTE setup_memory(void)
    

  384. {
    

  385.     BYTE i = 0;
    

  386.     for(; i < MAX_CHANNEL_MEM; ++i)
    

  387.     {
    

  388.         if(save_info.mem.memory[i] > 0 && save_info.mem.memory[i] == info.freq)
    

  389.         {
    

  390.             return i;
    

  391.         }
    

  392.     }
    

  393.     
    

  394.     return 0xFF;
    

  395. }
    


  396. 

  397. static void update_lcd(void)
    

  398. {
    

  399.     int num, dec;
    

  400.     char c[17] = {0};
    

  401.     BYTE memidx = 0;
    

  402.     char m[1] = {' '};
    

  403.     char m1[3] = {' ',' ', 0};
    

  404.     
    

  405.     static BYTE size = 0;
    

  406.     static BYTE pos  = 0;
    

  407.     static WORD ps   = 0;
    

  408.     
    

  409.     if(state < STATE_LAST_BASIC)
    

  410.     {
    

  411.         // Draw line 1
    

  412.         
    

  413.         if(state == STATE_MEMORY)
    

  414.         {
    

  415.             // Display current memory station
    

  416.             strncpypgm2ram(LCDText[0], (ROMCHAR)"       FM ---.- ", 16);
    

  417.             
    

  418.             if(save_info.mem.memory[mem_idx] > 0)
    

  419.             {
    

  420.                 num = save_info.mem.memory[mem_idx];
    

  421.                 dec = (int)floor(((save_info.mem.memory[mem_idx] - num) * 100)/10);
    

  422.                 if(dec % 2 == 0) dec += 1;
    

  423.                 sprintf(c, (ROMCHAR)"       FM %3d.%1d ", num, dec);
    

  424.                 strncpy(LCDText[0], c, 16);
    

  425.             }
    

  426.         }
    

  427.         else
    

  428.         {
    

  429.             // Display station currently tunned 
    

  430.             strncpypgm2ram(LCDText[0], (ROMCHAR)" \xA5\xA5 SCANNING \xA5\xA5 ", 16);
    

  431.             
    

  432.             //if(info.fmtrue && info.tuneok)
    

  433.             //{
    

  434.                 num = info.freq;
    

  435.                 dec = (int)floor(((info.freq - num) * 100)/10);
    

  436.                 if(dec % 2 == 0) dec += 1;
    


  437. 

  438.                 memidx = setup_memory();
    

  439.                 if(memidx != 0xFF) {
    

  440.                     itoa(memidx+1, m);
    

  441.                     m1[0] = 'M';
    

  442.                     m1[1] = m[0];
    

  443.                 }
    

  444.                 if(info.stereo)      
    

  445.                     sprintf(c, (ROMCHAR)"%1d %s   FM %3d.%1d\xA5", info.rssi, m1, num, dec);
    

  446.                 else
    

  447.                     sprintf(c, (ROMCHAR)"%1d %s   FM %3d.%1d ", info.rssi, m1, num, dec);
    


  448. 

  449.                 strncpy(LCDText[0], c, 16);
    

  450.                 
    

  451. if(info.fmtrue && info.tuneok)
    

  452. {
    

  453.                 // Start save timer
    

  454.                 if(save_info.enabled)
    

  455.                 {
    

  456.                     save_info.mem.channel = info.freq;
    

  457.                     save_info.mem_save_timeout = SAVE_TIMEOUT;
    

  458.                     save_info.enabled = 0;
    

  459.                 }
    

  460.             }
    

  461.         }
    

  462.         
    

  463.         switch(state)
    

  464.         {
    

  465.             case STATE_IDLE:
    

  466.             {
    

  467.                 if(!rds.use_rt && rds.ps_valid)
    

  468.                 {
    

  469.                     rds.ps_valid = 0;
    

  470.                     memset(LCDText[1], ' ', 16);
    

  471.                     strncpy(&LCDText[1][4], rds.ps_copy, 8);
    

  472.                 }
    

  473.                 else
    

  474.                 {
    

  475.                     if(rds.rt_valid)
    

  476.                     {
    

  477.                         rds.rt_valid = 0;
    

  478.                         memset(LCDText[1], ' ', 16);
    

  479.                         size = strlen(rds.rt_copy);
    

  480.                         pos = 0;
    

  481.                         ps = 0;
    

  482.                         strncpy(LCDText[1], rds.rt_copy, size > 16 ? 16 : size);
    

  483.                     }
    

  484.                     else 
    

  485.                     {
    

  486.                         if(rds.use_rt && ps++ > 30)
    

  487.                         {
    

  488.                             ps = 0;
    

  489.                             if(size < 16)
    

  490.                                 strncpy(LCDText[1], rds.rt_copy, size > 16 ? 16 : size);
    

  491.                             else
    

  492.                                 strncpy(LCDText[1], &rds.rt_copy[pos++], (size - pos) > 16 ? 16 : size);
    

  493.                         }
    

  494.                     }
    

  495.                 }
    

  496.             }
    

  497.             break;
    


  498. 

  499.             case STATE_VOLUME:
    

  500.                 update_volume();
    

  501.                 break;
    


  502. 

  503.             case STATE_MEMORY:
    

  504.             {
    

  505.                 switch(mem_idx)
    

  506.                 {
    

  507.                     case 0:
    

  508.                         strncpypgm2ram(LCDText[1], (ROMCHAR)"MEM \x0A51 2 3 4 5 6", 16);
    

  509.                         break;
    

  510.                     case 1:
    

  511.                         strncpypgm2ram(LCDText[1], (ROMCHAR)"MEM 1 \x0A52 3 4 5 6", 16);
    

  512.                         break;
    

  513.                     case 2:
    

  514.                         strncpypgm2ram(LCDText[1], (ROMCHAR)"MEM 1 2 \x0A53 4 5 6", 16);
    

  515.                         break;
    

  516.                     case 3:
    

  517.                         strncpypgm2ram(LCDText[1], (ROMCHAR)"MEM 1 2 3 \x0A54 5 6", 16);
    

  518.                         break;
    

  519.                     case 4:
    

  520.                         strncpypgm2ram(LCDText[1], (ROMCHAR)"MEM 1 2 3 4 \x0A55 6", 16);
    

  521.                         break;
    

  522.                     case 5:
    

  523.                         strncpypgm2ram(LCDText[1], (ROMCHAR)"MEM 1 2 3 4 5 \x0A56", 16);
    

  524.                         break;
    

  525.                     default:
    

  526.                         LOG((ROMCHAR)"ERR %d\r\n", mem_idx);
    

  527.                         mem_idx = 0;
    

  528.                         break;
    

  529.                 }
    

  530.             }        
    

  531.             break;
    

  532.         }
    

  533.     }
    

  534.     else
    

  535.     {
    

  536.         MENU_draw();
    

  537.     }
    

  538.     
    

  539.     LCDUpdate();
    

  540. }
    

  541.    


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

相关帖子
xinpian101 发表于 2024-9-28 21:00 | 显示全部楼层
只要实现I2C读写一般就没太多问题了。所以学会I2C很重要啊。
回复 赏

举报

coyoteie 发表于 2024-10-13 07:53 | 显示全部楼层
回复 赏

举报

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

本版积分规则

玛尼玛尼哄

196

主题

3258

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部