21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 基于CH32V307，LORA以及VHF频率通信的老人居家远程健康 ...
返回列表 发新帖我要提问

[RISC-V MCU 创新应用比赛] 基于CH32V307，LORA以及VHF频率通信的老人居家远程健康监测控制系统

[复制链接]
 楼主| donatello1996 发表于 2023-2-28 22:11 | 显示全部楼层 |阅读模式
LORA, VHF, 健康监测, 控制, 控制系统
本帖最后由 donatello1996 于 2023-2-28 23:26 编辑

简介：使用CH32V307-EVT评估板接上必要传感器外设，监测老人居家的环境温度、大气压、有害气体浓度、心率、血样、血氧、三轴加速度、三轴陀螺仪等指标，其中三轴加速度和三轴陀螺仪是为了监控老人是否发生摔倒的情况，通过400M LORA数字信号发送于老人子女手上的另一块电路板（以下以子女电路板代称），LORA通信距离视乎发射器功率，使老人子女可以通过子女电路板在一公里以内实时监测老人居家的上述指标，同时，CH32V307-EVT评估板还通过板上TTL串口控制一个VHF语音对讲模块，子女电路板上也接入一个相同型号，相同频率的VHF语音对讲模块，VHF在城市内可进行一公里内的无衰减异步语音通信，进行三公里内的衰减异步语音通信，老人和老人子女均可通过VHF语音对讲模块上的PTT按钮进行语音通话，而无需使用网络流量，开机即用，老人子女也可以通过串口方式对VHF语音对讲模块写频。除了上述功能外，老人手上的CH32V307-EVT评估板还带有手势识别模块和RDA5807收音机模块，以手势控制收音机模块的输出音量和自动搜索可用电台，用于老人日常消遣。此系统相比起之前兴起的4G、WIFI、NBIOT物联网智能家居系统，优势在于完全脱离网络流量限制，LORA通信和VHF通信都是高稳定性、超远距离、开机即用无需登录云平台的通信手段，140MHz和400MHz这两个频段使用大功率发射天线，可以满足一公里内的无衰减通信和三公里内的衰减通信，此系统一般用于老人与老人子女同住处，老人子女上班与出租屋距离不远的场合，若是老人与老人子女远于三公里，那就只能使用网络流量的方式通过云平台进行通信了。
硬件说明：
此系统使用到了CH32V307-EVT板上的I2C、SPI、串口、外部中断、AD接口、DA接口等外设，监测老人居家的环境温度和大气压所使用的模块为I2C接口的BMP280模块，该模块可以检测环境温度和大气压。监测有害气体浓度所使用的模块为电压输出和电平输出的MQ135模块，当MQ135模块检测到一氧化碳，甲醛等有害气体浓度大于阈值时，会在D0接口输出下降沿和持续的低电平，CH32V307-EVT评估板可通过外部中断进行监测。监测老人心率和血氧的模块是串口的MAX30102心率血氧采集模块，此模块需要使用手指尖进行检测，厂家后续第二代产品可升级为直接接触式检测，但输出方式不变，仍为串口。监测老人三轴加速度和三轴陀螺仪所使用的模块为I2C接口MPU6050模块。收音机模块为I2C接口的RDA5807模块，需要外接天线和扬声器使用。老人可通过I2C接口的PAJ7620模块进行手势控制，该模块支持八个手势控制，分别为前、后、左、右、上、下、顺时针、逆时针，检测灵敏度尚可，但肯定比不了独立按键直接控制，该模块厂家也在后续升级中。VHF语音对讲模块上集成了麦克风、扬声器和PTT发射按钮，CH32V307-EVT板也是通过串口进行VHF语音对讲模块控制。发射LORA数字信号所使用的模块为SPI接口+外部中断接口安信可RA02模块，主控为SX1278，需要配备发射天线。VHF语音对讲模块和安信可RA02模块都必须成对使用，也就是另外的一个VHF语音对讲模块和安信可RA02模块需要接到另外的电路板上进行无线通信。VHF语音对讲模块和安信可RA02模块的频段是错开的，VHF语音对讲模块可用频段为140-170MHz，安信可RA02模块可用频段为400-470MHz，两个模块一起使用不会造成任何干扰，但安信可RA02模块不可以与UHF模块同时使用（400-470MHz）。由于MPU6050模块对I2C硬件要求过高，所以使用独立的I2C总线，不与BMP280模块、PAJ7620模块、RDA5807模块同时使用。
微信截图_20230228224211.jpg
d738b183f593f09e135ed0c0f62b114.jpg b41635594025f370d02c9db59c589c7.jpg b3706368d9c97f8555e05d2d41d152c.jpg 5ebb8750976856f438922b436006558.jpg
f1827660c310f7c4f75971ad72b5495.jpg db8dabe3f180e0583eb52aac68a7f33.jpg d2d321ff7fbd9e14c5d6910db6a4458.jpg adcb701d0db5d37023905e416c6d35d.jpg 79359051bac94ec8d273ab9757e1925.jpg 85f75b49ada30f0c86e25e2125e8741.jpg 8e077eda2c24acd5c19c7a77f49be2e.jpg 6ca530d93eabf4fc48db1ea507bc65d.jpg


软件说明：
开发平台为VSCode，编译使用官方编译链riscv64-unknown-elf-toolchain-10.2.0-2020.12.8-x86_64-w64-mingw32，命令行编译：
微信截图_20230228231725.jpg
复制
  1. <div>riscv64-unknown-elf-gcc -g -O3 --specs=nosys.specs --specs=nano.specs -msave-restore -march=rv32imafc -mabi=ilp32 -msmall-data-limit=8 -fmessage-length=0 -fsigned-char -ffunction-sections -fdata-sections -fno-common -Wunused -Wuninitialized -nostartfiles -Xlinker -T ./Link/Link1.ld ./Startup/startup_ch32v30x_D8C1.S -I./Bsp -I./Core -I./Driver -I./Startup -I./User -I./Eth -L./Lib ./Startup/syscalls.c ./Startup/system_ch32v30x.c ./Driver/ch32v30x_adc.c ./Driver/ch32v30x_rcc.c ./Driver/ch32v30x_dac.c ./Driver/ch32v30x_misc.c ./Driver/ch32v30x_gpio.c ./Driver/ch32v30x_exti.c ./Driver/ch32v30x_spi.c ./Driver/ch32v30x_dma.c ./Driver/ch32v30x_tim.c ./Driver/ch32v30x_usart.c ./Driver/ch32v30x_i2c.c ./Bsp/debug.c ./Bsp/spi1_spi2.c ./Bsp/i2c.c ./Bsp/uart.c ./Bsp/adc_pa0.c ./Bsp/lora.c ./Bsp/bmp280.c ./Bsp/paj7620.c ./Bsp/mpu6050.c ./User/main.c ./User/ch32v30x_it.c -lm -o main</div><div>
    

  2. </div><div>riscv64-unknown-elf-objcopy -O binary main main.bin</div>
微信截图_20230228230110.jpg

此系统不带RTOS，完全由裸机实现，CH32V307设置主频为140MHz，初始化所有必要外设后进入主循环，主循环不间断读取AD电压值和手势传感器值，手势传感器值用于控制RDA5807模块调频和调音量，以及VHF语音模块。200个循环读取一次BMP280的电压值、温度值、MPU6050的三轴加速度值和三轴陀螺仪值，250个循环写入一次血氧和心跳的AT请求指令，300个循环读取一次AT返回数值，1000个循环进行一次LORA数字信号发送，10000个循环将有害气体告警字节清零：
复制
  1.    Delay_Init();
    

  2.     UART1_Init(115200);
    

  3.         printf("SystemClk:%d\n",SystemCoreClock);
    

  4.         printf("Leader Qiao is niubility.\n");
    

  5.         printf("Brother Long is lihaility.\n");
    

  6.         printf("Master XU is dalaoility.\n");
    


  7. 

  8.         UART2_Init(9600 , 1);
    

  9.         UART2_Send_String("UART2\n");
    


  10. 

  11.         ADC_Function_Init();
    

  12.         DAC1_Init();
    


  13. 

  14.     //W5500_Init();
    


  15. 

  16.         SPI1_Init();
    

  17.         SPI2_Init();
    

  18.         RA02_GPIO_Init();
    

  19.     RA02_EXTI8_Int_Init();
    

  20.         SX1276_Init(400 , 7);
    


  21. 

  22.         I2C_Init_PB6_PB7();
    

  23.         BMP280_Init();
    

  24.         PAJ7620_Init();
    


  25. 

  26.         I2C_Init_PD8_PD9();
    

  27.         MPU6050_Init();
    


  28. 

  29.         printf("RDA5807P_Intialization = %d\n" , RDA5807P_Intialization());
    


  30. 

  31.          while(1)
    

  32.         {
    


  33. 

  34.                 // if(mpu_dmp_get_data(&pitch , &roll , &yaw) == 0)
    

  35.                 // {
    

  36.                 //         MPU_Get_Accelerometer(&aacx,&aacy,&aacz);
    

  37.                 //         MPU_Get_Gyroscope(&gyrox,&gyroy,&gyroz);
    


  38. 

  39.                 //         printf("pitch = %d.%-3d roll = %d.%-3d yaw = %d.%-3d\n" ,
    

  40.                 //         (int)pitch , abs(((int)(pitch * 1000)) % 1000) , 
    

  41.                 //         (int)roll , abs(((int)(roll * 1000)) % 1000) , 
    

  42.                 //         (int)yaw , abs(((int)(yaw * 1000)) % 1000)
    

  43.                 //         );
    

  44.                 // }
    


  45. 

  46.                 ret = I2C_Read_Addr_PB6_PB7(PAJ7620_ID , 0x43);
    

  47.                 if(ret != 0)
    

  48.                 {
    

  49.                         switch(ret)
    

  50.                         {
    

  51.                                 case 16:
    

  52.                                 {
    

  53.                                         printf("Approach.\n");
    


  54. 

  55.                                         break;
    

  56.                                 }
    

  57.                                 case 32:
    

  58.                                 {
    

  59.                                         printf("Away.\n");
    

  60.                                         break;
    

  61.                                 }
    

  62.                                 case 4:
    

  63.                                 {
    

  64.                                         printf("Forward.\n");
    

  65.                                         break;
    

  66.                                 }
    

  67.                                 case 8:
    

  68.                                 {
    

  69.                                         printf("Backword.\n");
    

  70.                                         break;
    

  71.                                 }
    

  72.                                 case 2:
    

  73.                                 {
    

  74.                                         printf("Left.\n");
    

  75.                                         break;
    

  76.                                 }
    

  77.                                 case 1:
    

  78.                                 {
    

  79.                                         printf("Right.\n");
    

  80.                                         break;
    

  81.                                 }
    

  82.                                 case 64:
    

  83.                                 {
    

  84.                                         printf("Clockwise.\n");
    

  85.                                         break;
    

  86.                                 }
    

  87.                                 case 128:
    

  88.                                 {
    

  89.                                         printf("Anti-clockwise.\n");
    

  90.                                         break;
    

  91.                                 }
    

  92.                         }
    

  93.                 }
    


  94. 

  95.                 if(timer_count % 200 == 0)
    

  96.                 {
    

  97.                         adc_val = Get_ADC_Val(1);
    

  98.                         printf("adc_val = %d\n" , adc_val);
    

  99.                         lora_tx_buffer[2] = adc_val >> 8;
    

  100.                         lora_tx_buffer[3] = adc_val & 0xff;
    

  101.                         lora_tx_buffer[4] = 0;
    


  102. 

  103.                         BMP280_Read_Pressure_Tempature(&pres , &temp);
    

  104.                         asl = BMP280PressureToAltitude(&pres);
    

  105.                         printf("pres = %d.%-3d , temp = %d.%-3d , asl = %d.%-3d\n" , 
    

  106.                         (int)pres , abs(((int)(pres * 1000)) % 1000) , 
    

  107.                         (int)temp , abs(((int)(temp * 1000)) % 1000) ,
    

  108.                         (int)asl , abs(((int)(asl * 1000)) % 1000)
    

  109.                         );
    


  110. 

  111.                         lora_tx_buffer[6] = ((int)pres) >> 8;
    

  112.                         lora_tx_buffer[7] = ((int)pres) & 0xff;
    


  113. 

  114.                         lora_tx_buffer[8] = (((int)(pres * 65536)) & 65536) >> 8;
    

  115.                         lora_tx_buffer[9] = ((int)(pres * 65536)) & 0xff;
    


  116. 

  117.                         lora_tx_buffer[10] = ((int)temp) >> 8;
    

  118.                         lora_tx_buffer[11] = ((int)temp) & 0xff;
    

  119.                         
    

  120.                         aacx = I2C_Read_Addr_PD8_PD9(0x68 , ACCEL_XOUT_H) << 8 | I2C_Read_Addr_PD8_PD9(0x68 , ACCEL_XOUT_H + 1);
    

  121.                         aacy = I2C_Read_Addr_PD8_PD9(0x68 , ACCEL_YOUT_H) << 8 | I2C_Read_Addr_PD8_PD9(0x68 , ACCEL_YOUT_H + 1);
    

  122.                         aacz = I2C_Read_Addr_PD8_PD9(0x68 , ACCEL_ZOUT_H) << 8 | I2C_Read_Addr_PD8_PD9(0x68 , ACCEL_ZOUT_H + 1);
    

  123.                     printf("%d %d %d\n" , aacx , aacy , aacz);
    


  124. 

  125.                         lora_tx_buffer[12] = aacx >> 8;
    

  126.                         lora_tx_buffer[13] = aacx & 0xff;
    


  127. 

  128.                         lora_tx_buffer[14] = aacy >> 8;
    

  129.                         lora_tx_buffer[15] = aacy & 0xff;
    


  130. 

  131.                         lora_tx_buffer[16] = aacz >> 8;
    

  132.                         lora_tx_buffer[17] = aacz & 0xff;
    

  133.                 }
    


  134. 

  135.                 if(timer_count % 250 == 0)
    

  136.                 {
    

  137.                         printf("timer_count = %d\n" , timer_count);
    

  138.                         flag_spo2_heart = 1 - flag_spo2_heart;
    

  139.                         if(flag_spo2_heart == true)
    

  140.                                 UART2_Send_String("AT+HEART\r\n");
    

  141.                         else
    

  142.                                 UART2_Send_String("AT+SPO2\r\n");
    

  143.                 }
    

  144.                 if(timer_count % 300 == 0)
    

  145.                 {
    

  146.                         printf("spo2 = %d heart = %d\n" , spo2 , heart);
    

  147.                         lora_tx_buffer[18] = spo2 >> 8;
    

  148.                         lora_tx_buffer[19] = spo2 & 0xff;
    

  149.                         lora_tx_buffer[20] = heart >> 8;
    

  150.                         lora_tx_buffer[21] = heart & 0xff;
    

  151.                 }
    


  152. 

  153.                 // if(rec_start && !rec_stop)
    

  154.                 // {
    

  155.                 //         rec_adc_val[rec_count++] = Get_ADC_Val(0);
    

  156.                 //         printf("%d\n" , rec_adc_val[rec_count - 1]);
    

  157.                 //         DAC_SetChannel1Data(DAC_Align_12b_R, rec_adc_val[rec_count - 1]);
    

  158.                 // }
    

  159.                 // else if(!rec_start && rec_stop)
    

  160.                 // {
    

  161.                 //         rec_stop = false;
    

  162.                 //         printf("rec_count = %d\n" , rec_count);
    

  163.                 //         for(i = 0 ; i < rec_count ; i ++)
    

  164.                 //         {
    

  165.                 //                 DAC_SetChannel1Data(DAC_Align_12b_R, rec_adc_val[i]);
    

  166.                 //         }
    

  167.                 //         rec_count = 0;
    

  168.                 // }
    


  169. 

  170.                 if(timer_count % 1000 == 0)
    

  171.                 {
    

  172.                         printf("timer_count = %d\n" , timer_count);
    

  173.                         Lora_TxData(lora_tx_buffer , 50);
    

  174.                 }
    


  175. 

  176.                 if(timer_count % 10000 == 0)
    

  177.                 {
    

  178.                         lora_tx_buffer[4] = 0;
    

  179.                 }                
    


  180. 

  181.                 timer_count ++;
    


  182. 

  183.                 if(timer_count >= 1000000000)
    

  184.                         timer_count = 0;
    

  185.         }

BMP280模块初始化：
复制
  1. uint8_t BMP280_Init(void)
    

  2. {
    

  3.     uint8_t bmp280_id;
    

  4.     uint8_t tmp[1];
    


  5. 

  6.     I2C_Read_Datas_PB6_PB7(BMP280_SLAVE_ADDRESS, BMP280_CHIPID_REG, 1, &bmp280_id);
    


  7. 

  8.         printf("bmp280_id = 0x%x\n" , bmp280_id);
    


  9. 

  10.     I2C_Read_Datas_PB6_PB7(BMP280_SLAVE_ADDRESS, BMP280_DIG_T1_LSB_REG , 24 , (u8 *)&bmp280Cal);
    

  11.         
    

  12.         //printf("%d %d %d %d %d %d %d %d %d %d %d %d\n" ,
    

  13.         // bmp280Cal.dig_T1 , bmp280Cal.dig_T2 , bmp280Cal.dig_T3 ,
    

  14.         // bmp280Cal.dig_P1 , bmp280Cal.dig_P2 , bmp280Cal.dig_P3 , 
    

  15.         // bmp280Cal.dig_P4 , bmp280Cal.dig_P5 , bmp280Cal.dig_P6 , 
    

  16.         // bmp280Cal.dig_P7 , bmp280Cal.dig_P8 , bmp280Cal.dig_P9);
    


  17. 

  18.     tmp[0] = BMP280_MODE;
    

  19.     I2C_Write_Reg_Datas_PB6_PB7(BMP280_SLAVE_ADDRESS , BMP280_CTRLMEAS_REG , 1 , tmp);
    


  20. 

  21.     tmp[0] = 5 << 2;
    

  22.     I2C_Write_Reg_Datas_PB6_PB7(BMP280_SLAVE_ADDRESS , BMP280_CONFIG_REG , 1 , tmp);
    


  23. 

  24.     return bmp280_id;
    

  25. }


PAJ7620初始化：
复制
  1. void PAJ7620_Init()
    

  2. {
    

  3.     int i;
    

  4.     I2C_Write_Reg_Data_PB6_PB7(PAJ7620_ID , PAJ7620_REGITER_BANK_SEL , PAJ7620_BANK0);
    

  5.     I2C_Write_Reg_Data_PB6_PB7(PAJ7620_ID , PAJ7620_REGITER_BANK_SEL , PAJ7620_BANK0);
    

  6.     printf("PAJ7620 Init 0 = 0x%x\n" , I2C_Read_Addr_PB6_PB7(PAJ7620_ID , 0));
    

  7.     printf("PAJ7620 Init 1 = 0x%x\n" , I2C_Read_Addr_PB6_PB7(PAJ7620_ID , 1));
    


  8. 

  9.     for(i = 0 ; i < INIT_REG_ARRAY_SIZE ; i ++)
    

  10.         I2C_Write_Reg_Data_PB6_PB7(PAJ7620_ID , initRegisterArray[i][0] , initRegisterArray[i][1]);
    


  11. 

  12.     I2C_Write_Reg_Data_PB6_PB7(PAJ7620_ID , PAJ7620_REGITER_BANK_SEL , PAJ7620_BANK0);
    

  13. }


MPU6050初始化：
复制
  1. void MPU6050_Init()
    

  2. {
    

  3.         int ret;
    

  4.         ret = I2C_Read_Addr_PD8_PD9(0x68 , 0x75);
    

  5.         printf("MPU6050_Init = 0x%x\n" , ret);
    


  6. 

  7.         I2C_Write_Reg_Data_PD8_PD9(0x68 , SMPLRT_DIV , 7);
    

  8.         //Write to sample rate register
    

  9.         printf("SMPLRT_DIV = 0x%x\n" , I2C_Read_Addr_PD8_PD9(0x68 , SMPLRT_DIV));
    


  10. 

  11.         I2C_Write_Reg_Data_PD8_PD9(0x68 , PWR_MGMT_1 , 1);
    

  12.         // Write to power management register
    

  13.         printf("PWR_MGMT_1 = 0x%x\n" , I2C_Read_Addr_PD8_PD9(0x68 , PWR_MGMT_1));
    


  14. 

  15.         I2C_Write_Reg_Data_PD8_PD9(0x68 , CONFIG , 0);
    

  16.         // Write to Configuration register 
    

  17.         printf("CONFIG = 0x%x\n" , I2C_Read_Addr_PD8_PD9(0x68 , CONFIG));
    


  18. 

  19.         I2C_Write_Reg_Data_PD8_PD9 (0x68 , GYRO_CONFIG , 24);
    

  20.         // Write to Gyro Configuration register
    

  21.         printf("GYRO_CONFIG = 0x%x\n" , I2C_Read_Addr_PD8_PD9(0x68 , GYRO_CONFIG));
    


  22. 

  23.         I2C_Write_Reg_Data_PD8_PD9 (0x68 , INT_ENABLE , 1);
    

  24.         //Write to interrupt enable register
    

  25.         printf("INT_ENABLE = 0x%x\n" , I2C_Read_Addr_PD8_PD9(0x68 , INT_ENABLE));
    

  26. }


RDA5807初始化：
复制
  1. bool RDA5807P_Intialization(void)
    

  2. {
    

  3.         uint8_t error_ind = 0;
    

  4.         uint8_t RDA5807P_REGR[10]={0x0};
    

  5.     uint8_t i = 0;
    


  6. 

  7.     RDA5807P_REGW[0] = 0x00;
    

  8.     RDA5807P_REGW[1] = 0x02;
    


  9. 

  10.         error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807P_REGW[0], 2);
    

  11.         Delay_ms(50);
    


  12. 

  13.         error_ind = OperationRDAFM_2w(READ, (uint8_t *)&RDA5807P_REGR[0], 10);
    

  14.         Delay_ms(50);
    


  15. 

  16.     gChipID = RDA5807P_REGR[8];
    

  17.     gChipID = ((gChipID<<8) | RDA5807P_REGR[9]);
    


  18. 

  19.         printf("gChipID = %d\n" , gChipID);
    


  20. 

  21.     if (gChipID == 0x5808)  //RDA5807N
    

  22.     {
    

  23.         for (i=0;i<8;i++)
    

  24.             RDA5807P_REGW[i] = RDA5807N_initialization_reg[i];
    

  25.      
    

  26.         error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807N_initialization_reg[0], 2);
    

  27.         Delay_ms(600); 
    

  28.             error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807N_initialization_reg[0], sizeof(RDA5807N_initialization_reg));
    

  29.     }
    

  30.     else if (gChipID == 0x5804)     //RDA5807PE,RDA5807SP
    

  31.     {
    

  32.         for (i=0;i<8;i++)
    

  33.             RDA5807P_REGW[i] = RDA5807PE_initialization_reg[i];
    

  34.      
    

  35.         error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807PE_initialization_reg[0], 2);
    

  36.         Delay_ms(600); 
    

  37.             error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807PE_initialization_reg[0], sizeof(RDA5807PE_initialization_reg));
    

  38.     }
    

  39.     else if (gChipID == 0x5801)     //RDA5807H,RDA5807HP
    

  40.     {
    

  41.         for (i=0;i<8;i++)
    

  42.             RDA5807P_REGW[i] = RDA5807PH_initialization_reg[i];
    

  43.      
    

  44.         error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807PH_initialization_reg[0], 2);
    

  45.         Delay_ms(600); 
    

  46.             error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807PH_initialization_reg[0], sizeof(RDA5807PH_initialization_reg));
    

  47.         Delay_ms(100);
    


  48. 

  49.                 do
    

  50.                 {
    

  51.                         i++;
    

  52.                         if(i>10) 
    

  53.                                 return 0; 
    

  54.                         
    

  55.                 RDA5807P_SetFreq(8750);
    


  56. 

  57.                 Delay_ms(10);           
    


  58. 

  59.                 //read REG0A&0B        
    

  60.                 OperationRDAFM_2w(READ,&(RDA5807P_REGR[0]), 4);
    

  61.                 if((RDA5807P_REGR[3]&0x80)==0)
    

  62.                         {
    

  63.                                 RDA5807P_REGW[1] &= 0xFE;        
    

  64.                                 error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807P_REGW[0], 2);
    

  65.                                 Delay_ms(50);        
    

  66.                                 RDA5807P_REGW[1] |= 0x01;
    

  67.                                 error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807P_REGW[0], 2);
    

  68.                                 Delay_ms(50);
    


  69. 

  70.                 }
    

  71.                 }while((RDA5807P_REGR[3]&0x80)==0);
    

  72.     }
    

  73.     else
    

  74.     {
    

  75.         gChipID = RDA5807P_REGR[4];
    

  76.         gChipID = ((gChipID<<8) | RDA5807P_REGR[5]);
    

  77.     }
    

  78.     
    

  79.     if ((gChipID == 0x5802) || (gChipID == 0x5803))
    

  80.     {
    

  81.         gChipID = 0x5802;
    


  82. 

  83.         for (i=0;i<8;i++)
    

  84.             RDA5807P_REGW[i] = RDA5807P_initialization_reg[i];
    


  85. 


  86. 

  87.         error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807P_initialization_reg[0], 2);
    

  88.         Delay_ms(600); 
    

  89.         error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807P_initialization_reg[0], sizeof(RDA5807P_initialization_reg));
    


  90. 

  91.     }
    


  92. 

  93.         Delay_ms(50); 
    

  94.         
    

  95.         if (error_ind )
    

  96.            return 0;
    

  97.         else
    

  98.            return 1;
    

  99. }


读取血氧和心跳值使用串口空闲中断：
复制
  1. __attribute__((interrupt(), weak)) void USART2_IRQHandler(void)
    

  2. {
    

  3.         int i = 0;
    

  4.          if(USART_GetITStatus(USART2 , USART_IT_IDLE) != RESET)  
    

  5.         {
    

  6.                 USART_ReceiveData(USART2);
    

  7.                 DMA_Cmd(DMA1_Channel6 , DISABLE);  
    

  8.                 com2_rx_count = COM_RX_BUFFER_SIZE - DMA_GetCurrDataCounter(DMA1_Channel6);
    

  9.                 DMA1_Channel6->CNTR = COM_RX_BUFFER_SIZE;
    

  10.                 DMA_Cmd(DMA1_Channel6 , ENABLE);
    

  11.                 for(i = 0 ; i < com2_rx_count ; i ++)
    

  12.                 {
    

  13.                         if(com2_rx_buffer[i] == '+' && com2_rx_buffer[i + 1] == 'S' && com2_rx_buffer[i + 2] == 'P' 
    

  14.                         && com2_rx_buffer[i + 3] == 'O' && com2_rx_buffer[i + 4] == '2'  && com2_rx_buffer[i + 5] == '='
    

  15.                         && com2_rx_buffer[i + 6] != 'N'
    

  16.                         )
    

  17.                         {
    

  18.                                 spo2 =  (com2_rx_buffer[i + 6] - '0') * 10 + com2_rx_buffer[i + 7] - '0';
    

  19.                         }
    

  20.                         if(com2_rx_buffer[i] == '+' && com2_rx_buffer[i + 1] == 'H' && com2_rx_buffer[i + 2] == 'E' 
    

  21.                         && com2_rx_buffer[i + 3] == 'A' && com2_rx_buffer[i + 4] == 'R'  && com2_rx_buffer[i + 5] == 'T'
    

  22.                         && com2_rx_buffer[i + 6] == '=' && com2_rx_buffer[i + 7] != 'N'
    

  23.                         )
    

  24.                         {
    

  25.                                 heart = com2_rx_buffer[i + 7] - '0';
    


  26. 

  27.                                 if('0' <= com2_rx_buffer[i + 8] && com2_rx_buffer[i + 8] <= '9')
    

  28.                                 {
    

  29.                                         heart = (com2_rx_buffer[i + 7] - '0') * 10 + com2_rx_buffer[i + 8] - '0';
    

  30.                                 }
    


  31. 

  32.                                 if('0' <= com2_rx_buffer[i + 9] && com2_rx_buffer[i + 9] <= '9')
    

  33.                                 {
    

  34.                                         heart = (com2_rx_buffer[i + 7] - '0') * 100 + (com2_rx_buffer[i + 8] - '0') * 10 + com2_rx_buffer[i + 9] - '0';
    

  35.                                 }
    

  36.                                 
    

  37.                         }
    

  38.                 }
    


  39. 

  40.         }
    

  41. }


SX1276初始化：
复制
  1. SX1276初始化：
    

  2. void SPI1_Init()
    

  3. {
    

  4.     GPIO_InitTypeDef GPIO_InitStructure = {0};
    

  5.     SPI_InitTypeDef  SPI_InitStructure = {0};
    


  6. 

  7.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE);
    


  8. 

  9.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE );
    

  10.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE );
    


  11. 

  12.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    

  13.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  14.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  15.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  16. 

  17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  18.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  19.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  20. 

  21.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    

  22.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  23.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  24.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  25. 

  26.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    

  27.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    

  28.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    

  29.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    

  30.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    

  31.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    

  32.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
    

  33.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    

  34.     SPI_InitStructure.SPI_CRCPolynomial = 7;
    

  35.     SPI_Init(SPI1, &SPI_InitStructure);
    

  36.     SPI_Cmd(SPI1, ENABLE);
    


  37. 

  38. }
    


  39. 

  40. uint8_t SPI1_ReadWriteByte(uint8_t data)
    

  41. {                
    

  42.         uint8_t retry = 0;                                         
    

  43.         while ((SPI1->STATR & SPI_I2S_FLAG_TXE) == RESET) 
    

  44.         {
    

  45.                 retry ++;
    

  46.                 if(retry > 200)return 0;
    

  47.         }                          
    

  48.         SPI1->DATAR = data;
    

  49.         retry=0;
    


  50. 

  51.         while ((SPI1->STATR & SPI_I2S_FLAG_RXNE) == RESET)
    

  52.         {
    

  53.                 retry ++;
    

  54.                 if(retry > 200)return 0;
    

  55.     }
    

  56.         return SPI1->DATAR;
    

  57. }
    


  58. 

  59. void SX1276_Init(uint32_t fre , uint8_t bw)
    

  60. {    
    

  61.     xLORA.InitOK = 0;
    

  62.     LoRaSettings.RFFrequency = fre * 1000 * 1000;
    

  63.     LoRaSettings.SpreadingFactor = 11;
    

  64.     LoRaSettings.SignalBw = bw;
    

  65.     
    

  66.     SX1276_Reset();   
    


  67. 

  68.         SX1276Read(0x06, ®Temp ,1);
    

  69.         while(regTemp != 0x6C)
    

  70.         {
    

  71.             printf("SX1276_Init error.\n");
    

  72.             Delay_ms(300);
    

  73.         }
    

  74.    
    

  75.     SX1276_SetOpMode(RFLR_OPMODE_SLEEP);
    


  76. 

  77.     SX1276Read(0x01, ®Temp , 1);
    

  78.     printf("0x01 regTemp = 0x%x\n" , regTemp);
    

  79.     regTemp |= 0x80 ;        
    

  80.     SX1276Write( 0x01, ®Temp , 1);
    

  81.     SX1276Read (0x01, ®Temp , 1);
    

  82.         printf("0x01 regTemp = 0x%x\n" , regTemp);
    

  83.     
    

  84.     regTemp  = RFLR_LNA_GAIN_G1;
    

  85.     SX1276Write ( REG_LR_LNA , ®Temp , 1);
    

  86.     
    

  87.     SX1276LoRaSetRFFrequency(LoRaSettings.RFFrequency);
    

  88.     SX1276LoRaSetSpreadingFactor(LoRaSettings.SpreadingFactor);
    

  89.     SX1276LoRaSetErrorCoding(LoRaSettings.ErrorCoding);
    

  90.     SX1276LoRaSetPacketCrcOn(LoRaSettings.CrcOn);
    

  91.     SX1276LoRaSetSignalBandwidth(LoRaSettings.SignalBw);
    


  92. 

  93.     SX1276LoRaSetImplicitHeaderOn(LoRaSettings.ImplicitHeaderOn );
    

  94.     SX1276LoRaSetSymbTimeout(0x3FF);
    

  95.         
    

  96.     SX1276Write( 0x22, &LoRaSettings.PayloadLength , 1 );
    

  97.     
    

  98.     SX1276LoRaSetLowDatarateOptimize( true );
    

  99.    
    

  100.     SX1276LoRaSetPAOutput( RFLR_PACONFIG_PASELECT_PABOOST );
    

  101.     
    

  102.     regTemp = 0x87;
    

  103.     SX1276Write(REG_LR_PADAC , ®Temp , 1);
    

  104.     regTemp = 0x8F;    
    

  105.     SX1276Write(REG_LR_PACONFIG , ®Temp , 1);
    

  106.     
    

  107.     //SX1276Read (0x26, ®Temp , 1);
    

  108.     //regTemp = (regTemp & 0xF7) | ( 1<<3);
    

  109.     //SX1276Write (0x26, ®Temp, 1);       
    

  110.     
    

  111.     regTemp = 0xFF;
    

  112.     SX1276Write(REG_LR_IRQFLAGS ,®Temp, 1);
    


  113. 

  114.     xLORA.InitOK = 1;    
    

  115.     
    

  116.     Lora_RxMode(0);
    

  117.     printf("SX1276_Init OK.\n");
    

  118. }  

SX1276使用外部中断进行发送缓冲区清零：
复制
  1. __attribute__((interrupt(), weak)) void LORA_DIO0_HANDLER(void)
    

  2. {
    


  3. 

  4.     EXTI_ClearITPendingBit(LORA_DIO0_PIN);
    

  5.     printf("LORA_DIO0_HANDLER xLORA.TxMode = %d xLORA.RxMode = %d\n" , xLORA.TxMode , xLORA.RxMode);
    

  6.     if(xLORA.TxMode == 1)   
    

  7.     {
    

  8.         printf("LORA_DIO0_HANDLER xLORA.TxMode = 1\n");
    

  9.         regTemp = 0xFF;
    

  10.         SX1276Write( 0x12, ®Temp , 1);                 
    

  11.         xLORA.TxMode = 0;
    

  12.                  
    

  13.         Lora_RxMode(0);
    

  14.         xLORA .RxMode = 1;
    

  15.               
    

  16.         return;
    

  17.     }
    

  18.     
    

  19.     if(xLORA.RxMode == 1)
    

  20.         {            
    

  21.         regTemp = 0xFF;
    

  22.         SX1276Write( 0x12, ®Temp ,1 );           
    

  23.     
    

  24.         if( LoRaSettings.ImplicitHeaderOn == true ) 
    

  25.                 RxSize = LoRaSettings.PayloadLength ;       
    

  26.         else
    

  27.                 SX1276Read( REG_LR_NBRXBYTES, &RxSize, 1 ); 
    

  28.         
    

  29.         SX1276Read( REG_LR_FIFORXCURRENTADDR, ®Temp ,1);
    

  30.         SX1276Write( REG_LR_FIFOADDRPTR, ®Temp ,1 );
    

  31.         SX1276Read(0, RxBuffer, RxSize );   
    

  32.                 
    

  33.         printf("RxSize %d RxBuffer: %s\r" , RxSize , RxBuffer);    
    

  34.         }
    

  35. }


回复 赏

举报

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

本版积分规则

donatello1996

8

主题

56

帖子

0

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

8

主题

56

帖子

0

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