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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › STM32单片机+ads1292心率检测显示程序
返回列表 发新帖
查看: 2661|回复: 0
打印 上一主题 下一主题
收起左侧

STM32单片机+ads1292心率检测显示程序

[复制链接]
跳转到指定楼层
楼主
ID:1067025 发表于 2023-3-20 00:48 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
该演示程序使用的芯片为：STM32F103C8T6

功能：
    单片机采集ADS1292模块数据，通过串口输出。
串口：
    UART1
    波特率：115200
    停止位：1
    数据为：8
    奇偶校验：无   


引脚定义及连线：
    1292模块--STM32F1：
    VDD---3.3V/5V
    GND---GND
    DRDY---PA8
    CS---PB12
    SCK---PB13
    MISO---PB14
    MOSI---PB15

单片机源程序如下:
  1. #include "ADS1292.h"
  2. #include "spi.h"
  3. #include "delay.h"
  4. #include "usart.h"
  5. #include "Timer.h"
  6. #include "key.h"
  7. #include "led.h"



  11. #define DEBUG_ADS1292        //寄存器printf调试


  14. u8 ADS1292_REG[12];                //ads1292寄存器数组
  15. ADS1292_CONFIG1         Ads1292_Config1                ={DATA_RATE};                                                                                                                                                                //CONFIG1
  16. ADS1292_CONFIG2         Ads1292_Config2                ={PDB_LOFF_COMP,PDB_REFBUF,VREF,CLK_EN,INT_TEST};                //CONFIG2
  17. ADS1292_CHSET                 Ads1292_Ch1set                ={CNNNLE1_POWER,CNNNLE1_GAIN,CNNNLE1_MUX};                                        //CH1SET
  18. ADS1292_CHSET                 Ads1292_Ch2set                ={CNNNLE2_POWER,CNNNLE2_GAIN,CNNNLE2_MUX};                                        //CH2SET
  19. ADS1292_RLD_SENS        Ads1292_Rld_Sens        ={PDB_RLD,RLD_LOFF_SENSE,RLD2N,RLD2P,RLD1N,RLD1P};        //RLD_SENS
  20. ADS1292_LOFF_SENS        Ads1292_Loff_Sens        ={FLIP2,FLIP1,LOFF2N,LOFF2P,LOFF1N,LOFF1P};                                        //LOFF_SENS
  21. ADS1292_RESP1                        Ads1292_Resp1                        ={RESP_DEMOD_EN1,RESP_MOD_EN,RESP_PH,RESP_CTRL};                //RSP1
  22. ADS1292_RESP2                        Ads1292_Resp2                        ={CALIB,FREQ,RLDREF_INT};                                                                                                                //RSP2

  24.        

  26. //ADS1292的IO口初始化       
  27. void ADS1292_Init(void)
  28. {               
  29.                 GPIO_InitTypeDef         GPIO_InitStructure;       
  30.                 EXTI_InitTypeDef         EXTI_InitStructure;
  31.                 NVIC_InitTypeDef        NVIC_InitStructure;
  32.        
  33.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO, ENABLE);          
  34.                 SPI2_Init();//初始化SPI引脚       
  35.                                                                         //250ns 频率4.5M        发送八组时钟需要23 us       
  36.                                                                         //125ns 频率9M，                发送八组时钟需要14 us       
  37.                                                                         //55ns 频率18M                发送八组时钟需要9.2us
  38.                                                                         //30ns 36M                                发送八组时钟需要9.2us
  39.                                                                         //手册10页里写的最小时钟周期为50ns                       
  40.                 //DRDY        //待机时高电平，采集时低电平有效
  41.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  42.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//上拉输入
  43.                 GPIO_Init(GPIOC, &GPIO_InitStructure);               
  44.                 //CS
  45.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
  46.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  47.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
  48.                 GPIO_Init(GPIOB, &GPIO_InitStructure);       
  49.                
  50. //                //RESRT
  51. //                GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  52. //                GPIO_Init(GPIOA, &GPIO_InitStructure);       
  53. //                //START
  54. //                GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  55. //                GPIO_Init(GPIOA, &GPIO_InitStructure);       
  56. //                //CLKSEL
  57. //                GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  58. //                GPIO_Init(GPIOA, &GPIO_InitStructure);               


  61.                 //DRDY中断初始化
  62.           EXTI_ClearITPendingBit(EXTI_Line8);//清除中断标志
  63.           GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource8);//选择管脚
  64.           EXTI_InitStructure.EXTI_Line=EXTI_Line8;                                                 //选择中断线路
  65.           EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;         //设置为中断请求，非事件请求
  66.           EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发
  67.           EXTI_InitStructure.EXTI_LineCmd = ENABLE;                                                 //外部中断使能
  68.           EXTI_Init(&EXTI_InitStructure);         
  69.                
  70.                 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  71.           NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;                                        //选择中断通道
  72.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;        //抢占优先级
  73.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                                //子优先级
  74.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                //使能外部中断通道
  75.           NVIC_Init(&NVIC_InitStructure);
  76.                
  77.                 EXTI->IMR &= ~(EXTI_Line8);//屏蔽外部中断       
  78.                 ADS_CS=1;               
  79.                 ADS1292_PowerOnInit();//上电复位，进入待机模式       
  80. }

  82. volatile u8 ads1292_recive_flag=0;        //数据读取完成标志
  83. volatile u8 ads1292_Cache[9];        //数据缓冲区


  86. void EXTI9_5_IRQHandler(void)
  87. {
  88.        
  89.                 if(EXTI->IMR&EXTI_Line8 && ADS_DRDY==0)//数据接收中断                               
  90.                 {               
  91.                                 EXTI_ClearITPendingBit(EXTI_Line8);        
  92.                                 ADS1292_Read_Data(ads1292_Cache);//数据存到9字节缓冲区
  93.                                 ads1292_recive_flag=1;
  94.                 }       
  95. }



  99. //读取72位的数据1100+LOFF_STAT[4:0]+GPIO[1:0]+13个0+2CHx24位，共9字节
  100. //        1100        LOFF_STAT[4                        3                        2                        1                        0        ]        //导联脱落相关的信息在LOFF_STAT寄存器里
  101. //                                                                        RLD                1N2N        1N2P        1N1N        1N1P       
  102. //        例        C0 00 00 FF E1 1A FF E1 52       

  104. u8 ADS1292_Read_Data(u8 *data)//72M时钟下函数耗时大约10us  8M时钟下 函数耗时大约 100us
  105. {               
  106.                 u8 i;       
  107.                
  108.                 ADS_CS=0;//读9个字节的数据
  109.                 //delay_us(10);
  110.                 for(i=0;i<9;i++)
  111.                 {       
  112.                                 *data=ADS1292_SPI(0X00);       
  113.                                 data++;
  114.                 }
  115.                 //delay_us(10);
  116.                 ADS_CS=1;               
  117.                 return 0;
  118. }


  121. //设置寄存器数组
  122. void ADS1292_SET_REGBUFF(void)
  123. {
  124.         ADS1292_REG[ID] =        ADS1292_DEVICE;//ID只读
  125.          
  126.         ADS1292_REG[CONFIG1] =        0x00;                //0000 0aaa        [7] 0连续转换模式  [6:3] 必须为0
  127.         ADS1292_REG[CONFIG1] |=        Ads1292_Config1.Data_Rate;//[2:0] aaa 采样率设置采样率

  129.         ADS1292_REG[CONFIG2] =        0x00;                //1abc d0e1        [7] 必须为1  [2] 必须为0  [0] 设置测试信号为1HZ、±1mV方波
  130.         ADS1292_REG[CONFIG2] |=        Ads1292_Config2.Pdb_Loff_Comp<<6;        //[6]a 导联脱落比较器是否掉电
  131.         ADS1292_REG[CONFIG2] |=        Ads1292_Config2.Pdb_Refbuf<<5;                //[5]b 内部参考缓冲器是否掉电
  132.         ADS1292_REG[CONFIG2] |=        Ads1292_Config2.Vref<<4;                                        //[4]c 内部参考电压设置，默认2.42V
  133.         ADS1292_REG[CONFIG2] |=        Ads1292_Config2.Clk_EN<<3;                                //[3]d CLK引脚输出时钟脉冲？
  134.         ADS1292_REG[CONFIG2] |=        Ads1292_Config2.Int_Test<<1;                        //[1]e 是否打开内部测试信号,
  135.         ADS1292_REG[CONFIG2] |=        0x81;//设置默认位
  136.        
  137.         ADS1292_REG[LOFF] =        0x10;//[7:5]        设置导联脱落比较器阈值 [4]        必须为1                 [3:2] 导联脱落电流幅值                [1]        必须为0        [0]        导联脱落检测方式 0 DC 1 AC

  139.         ADS1292_REG[CH1SET] =        0x00;         //abbb cccc
  140.         ADS1292_REG[CH1SET] |=Ads1292_Ch1set.PD<<7;                //[7]  a                 通道1断电？
  141.         ADS1292_REG[CH1SET] |=Ads1292_Ch1set.GAIN<<4;        //[6:4]bbb        设置PGA增益
  142.         ADS1292_REG[CH1SET] |=Ads1292_Ch1set.MUX;                        //[3:0]cccc        设置通道1输入方式

  144.         ADS1292_REG[CH2SET] =        0x00;        //abbb cccc
  145.         ADS1292_REG[CH2SET] |=Ads1292_Ch2set.PD<<7;                //[7]  a                 通道2断电？
  146.         ADS1292_REG[CH2SET] |=Ads1292_Ch2set.GAIN<<4;        //[6:4]bbb        设置PGA增益
  147.         ADS1292_REG[CH2SET] |=Ads1292_Ch2set.MUX;                        //[3:0]cccc        设置通道2输入方式
  148.        
  149.         ADS1292_REG[RLD_SENS] = 0X00; //11ab cdef        [7:6] 11 PGA斩波频率        fMOD/4
  150.         ADS1292_REG[RLD_SENS] |=Ads1292_Rld_Sens.Pdb_Rld<<5;                                        //[5]a        该位决定RLD缓冲电源状态
  151.         ADS1292_REG[RLD_SENS] |=Ads1292_Rld_Sens.Rld_Loff_Sense<<4;        //[4]b        该位使能RLD导联脱落检测功能
  152.         ADS1292_REG[RLD_SENS] |=Ads1292_Rld_Sens.Rld2N<<3;                                                //[3]c        这个位控制通道2负输入        用于右腿驱动的输出
  153.         ADS1292_REG[RLD_SENS] |=Ads1292_Rld_Sens.Rld2P<<2;                                                //[2]d        该位控制通道2正输入                用于右腿驱动的输出
  154.         ADS1292_REG[RLD_SENS] |=Ads1292_Rld_Sens.Rld1N<<1;                                                //[1]e        这个位控制通道1负输入        用于右腿驱动的输出
  155.         ADS1292_REG[RLD_SENS] |=Ads1292_Rld_Sens.Rld1P;                                                        //[0]f        该位控制通道1正输入                用于右腿驱动的输出       
  156.         ADS1292_REG[RLD_SENS] |=        0xc0;//设置默认位

  158.         ADS1292_REG[LOFF_SENS] = 0X00;  //00ab cdef        [7:6] 必须为0
  159.         ADS1292_REG[LOFF_SENS] |=Ads1292_Loff_Sens.Flip2<<5;                //[5]a        这个位用于控制导联脱落检测通道2的电流的方向
  160.         ADS1292_REG[LOFF_SENS] |=Ads1292_Loff_Sens.Flip1<<4;                //[4]b        这个位控制用于导联脱落检测通道1的电流的方向
  161.         ADS1292_REG[LOFF_SENS] |=Ads1292_Loff_Sens.Loff2N<<3;        //[3]c        该位控制通道2负输入端的导联脱落检测
  162.         ADS1292_REG[LOFF_SENS] |=Ads1292_Loff_Sens.Loff2P<<2;        //[2]d        该位控制通道2正输入端的导联脱落检测
  163.         ADS1292_REG[LOFF_SENS] |=Ads1292_Loff_Sens.Loff1N<<1;        //[1]e        该位控制通道1负输入端的导联脱落检测
  164.         ADS1292_REG[LOFF_SENS] |=Ads1292_Loff_Sens.Loff1P;                        //[0]f        该位控制通道1正输入端的导联脱落检测
  165.        
  166.         ADS1292_REG[LOFF_STAT] =        0x00;                //[6]0 设置fCLK和fMOD之间的模分频比 fCLK=fMOD/4  [4:0]只读，导联脱落和电极连接状态
  167.        
  168.         ADS1292_REG[RESP1] = 0X00;//abcc cc1d
  169.         ADS1292_REG[RESP1] |=Ads1292_Resp1.RESP_DemodEN<<7;//[7]a                这个位启用和禁用通道1上的解调电路               
  170.         ADS1292_REG[RESP1] |=Ads1292_Resp1.RESP_modEN<<6;        //[6]b                这个位启用和禁用通道1上的调制电路       
  171.         ADS1292_REG[RESP1] |=Ads1292_Resp1.RESP_ph<<2;                        //[5:2]c        这些位控制呼吸解调控制信号的相位       
  172.         ADS1292_REG[RESP1] |=Ads1292_Resp1.RESP_Ctrl;                        //[0]d                这个位设置呼吸回路的模式
  173.         ADS1292_REG[RESP1] |=        0x02;//设置默认位       
  174.        
  175.         ADS1292_REG[RESP2] = 0x00; //a000 0bc1        [6:3]必须为0 [0]必须为1
  176.         ADS1292_REG[RESP2] |=        Ads1292_Resp2.Calib<<7;                                //[7]a 启动通道偏移校正？
  177.         ADS1292_REG[RESP2] |=        Ads1292_Resp2.freq<<2;                                //[2]b 呼吸频率设置
  178.         ADS1292_REG[RESP2] |=        Ads1292_Resp2.Rldref_Int<<1;        //[1]c RLDREF信号源外部馈电？
  179.         ADS1292_REG[RESP2] |= 0X01;//设置默认位       

  181.         ADS1292_REG[GPIO] =        0x0C;                        //GPIO设为输入                [7:4]必须为0         [3:2]11 GPIO为输入 [1:0] 设置输入时，指示引脚电平，设置输出时控制引脚电平
  182. }

  184. //通过SPI总线与ADS1292通信
  185. u8 ADS1292_SPI(u8 com)
  186. {       
  187.                 return SPI2_ReadWriteByte(com);
  188. }
  189. //写命令
  190. void ADS1292_Send_CMD(u8 data)
  191. {
  192.                 ADS_CS=0;
  193.                 delay_us(100);
  194.                 ADS1292_SPI(data);               
  195.                 delay_us(100);       
  196.                 ADS_CS=1;
  197. }


  200. /*ADS1291、ADS1292和ADS1292R串行接口以字节形式解码命令，需要4个tCLK周期来解码和执行.
  201. 因此，在发送多字节命令时，4 tCLK周期必须将一个字节(或操作码)的结束与下一个字节(或操作码)分开。
  202. 假设CLK（时钟）为512 kHz，则tSDECODE (4 tCLK)为7.8125 us。
  203. 当SCLK（数据速率）为16mhz时，一个字节可以在500ns中传输，此字节传输时间不符合tSDECODE规范;
  204. 因此，必须插入一个延迟，以便第二个字节的末尾晚于7.3125us到达。
  205. 如果SCLK为1 MHz，则在8u秒内传输一个字节。由于此传输时间超过tSDECODE规范，处理器可以不延迟地发送后续字节。
  206. 在后面的场景中，可以对串行端口进行编程，使其从每个循环的单字节传输转移到多个字节*/

  208. //读写多个寄存器
  209. void ADS1292_WR_REGS(u8 reg,u8 len,u8 *data)
  210. {
  211.                 u8 i;
  212.                 ADS_CS=0;       
  213.                 delay_us(100);
  214.                 ADS1292_SPI(reg);
  215.                 delay_us(100);
  216.                 ADS1292_SPI(len-1);
  217.                 if(reg&0x40) //写
  218.                 {
  219.                                 for(i=0;i<len;i++)
  220.                                 {
  221.                                                 delay_us(100);               
  222.                                                 ADS1292_SPI(*data);
  223.                                                 data++;                               
  224.                                 }                       
  225.                 }
  226.                 else //读               
  227.                 {
  228.                                 for(i=0;i<len;i++)
  229.                                 {
  230.                                                 delay_us(100);               
  231.                                                 *data = ADS1292_SPI(0);
  232.                                                 data++;
  233.                                 }
  234.                 }                       
  235.                 delay_us(100);       
  236.                 ADS_CS=1;
  237. }


  240. //寄存器数组写入寄存器
  241. u8 ADS1292_WRITE_REGBUFF(void)
  242. {
  243.                 u8 i,res=0;
  244.                 u8 REG_Cache[12];        //存储寄存器数据
  245.                 ADS1292_SET_REGBUFF();//设置寄存器数组               
  246.                 ADS1292_WR_REGS(WREG|CONFIG1,11,ADS1292_REG+1);//数组变量写入寄存器
  247.                 delay_ms(10);               
  248.                 ADS1292_WR_REGS(RREG|ID,12,REG_Cache);//读寄存器
  249.                 delay_ms(10);       
  250.                
  251.                 //        #ifdef DEBUG_ADS1292       
  252.                 //                printf("WRITE REG:\r\n");
  253.                 //                for(i=0;i<12;i++        )//要写的数据                                                               
  254.                 //                                printf("%d %x\r\n",i,ADS1292_REG[i]);       
  255.                 //                printf("READ REG:\r\n");
  256.                 //        #endif       
  257.        
  258.        
  259.                 for(i=0;i<12;i++        )        //检查寄存器       
  260.                 {                                               
  261.                                 if(ADS1292_REG[i] != REG_Cache[i])
  262.                                 {
  263.                                                 if(i!= 0 && i!=8 && i != 11)        //0 8 和11是ID 导联脱落和GPIO相关
  264.                                                                 res=1;
  265.                                                 else
  266.                                                                 continue;
  267.                                 }                                       
  268.                 //                        #ifdef DEBUG_ADS1292
  269.                 //                                printf("%d %x\r\n",i,REG_Cache[i]); //读到的数据                       
  270.                 //                        #endif
  271.                   }       

  273.                 #ifdef DEBUG_ADS1292       
  274.                         if(res == 0)
  275.                                         printf("REG write success\r\n");
  276.                         else               
  277.                                         printf("REG write err\r\n");
  278.                 #endif
  279.                 return res;                               
  280. }


  283. void ADS1292_PowerOnInit(void)
  284. {       
  285.                 u8 i;
  286.                 u8 REG_Cache[12];       
  287.        
  288. //                ADS_CLKSEL=1;//启用内部时钟
  289. //                ADS_START=0; //停止数据输出       
  290. //                ADS_RESET=0; //复位
  291. //                delay_ms(1000);
  292. //                ADS_RESET=1;//芯片上电，可以使用       
  293. //                delay_ms(100);        //等待稳定
  294.        
  295.                 ADS1292_Send_CMD(SDATAC);//发送停止连续读取数据命令
  296.                 delay_ms(100);       
  297.                 ADS1292_Send_CMD(RESET);//复位
  298.                 delay_s(1);               
  299.                 ADS1292_Send_CMD(SDATAC);//发送停止连续读取数据命令
  300.                 delay_ms(100);               
  301.        
  302.                 //#ifdef DEBUG_ADS1292       
  303.                 //                ADS1292_WR_REGS(RREG|ID,12,REG_Cache);
  304.                 //                printf("read default REG:\r\n");
  305.                 //                for(i=0;i<12;i++        )        //读默认寄存器
  306.                 //                                printf("%d %x\r\n",i,REG_Cache[i]);               
  307.                 //#endif
  308.                 //ADS1292_Send_CMD(STANDBY);//进入待机模式       
  309. }



  313. //设置通道1内部1mV测试信号
  314. u8 ADS1292_Single_Test(void) //注意1292R开了呼吸解调，会对通道一的内部测试信号波形造成影响，这里只参考通道2即可，1292不受影响
  315. {
  316.                 u8 res=0;
  317.                 Ads1292_Config2.Int_Test = INT_TEST_ON;//打开内部测试信号
  318.                 Ads1292_Ch1set.MUX=MUX_Test_signal;//测试信号输入       
  319.                 Ads1292_Ch2set.MUX=MUX_Test_signal;//测试信号输入       
  320.                
  321.                 if(ADS1292_WRITE_REGBUFF())//写入寄存器
  322.                                 res=1;       
  323.                 delay_ms(10);                       
  324.                 return res;               
  325. }
  326. //设置内部噪声测试
  327. u8 ADS1292_Noise_Test(void)
  328. {
  329.                 u8 res=0;
  330.                 Ads1292_Config2.Int_Test = INT_TEST_OFF;//关内部测试信号
  331.                 Ads1292_Ch1set.MUX = MUX_input_shorted;//输入短路       
  332.                 Ads1292_Ch2set.MUX = MUX_input_shorted;//输入短路       

  334.                 if(ADS1292_WRITE_REGBUFF())//写入寄存器
  335.                                 res=1;       
  336.                 delay_ms(10);                       
  337.                 return res;                       
  338. }

  340. //正常信号采集模式
  341. u8 ADS1292_Single_Read(void)
  342. {
  343.                 u8 res=0;
  344.                 Ads1292_Config2.Int_Test = INT_TEST_OFF;//关内部测试信号
  345.                 Ads1292_Ch1set.MUX = MUX_Normal_input;//普通电极输入
  346.                 Ads1292_Ch2set.MUX = MUX_Normal_input;//普通电极输入
  347.        
  348.                 if(ADS1292_WRITE_REGBUFF())//写入寄存器
  349.                                 res=1;
  350.                 delay_ms(10);               
  351.                 return res;               
  352. }       

  354. //配置ads1292采集方式
  355. u8 Set_ADS1292_Collect(u8 mode)
  356. {
  357.                 u8 res;
  358.                
  359.                 delay_ms(10);       
  360.                 switch(mode)//设置采集方式
  361.                 {
  362.                                 case 0:
  363.                                         res =ADS1292_Single_Read();                                                                                               
  364.                                 break;
  365.                                 case 1:
  366.                                         res =ADS1292_Single_Test();                                                                                       
  367.                                 break;
  368.                                 case 2:
  369.                                         res =ADS1292_Noise_Test();                                                                                       
  370.                                 break;
  371.                 }               
  372.                 if(res)return 1;//寄存器设置失败               
  373.                 ADS1292_Send_CMD(RDATAC); //启动连续模式
  374.                 delay_ms(10);               
  375.                 ADS1292_Send_CMD(START);        //发送开始数据转换（等效于拉高START引脚）       
  376.                 delay_ms(10);               
  377.                 return 0;
  378. }
复制代码


  1. #include "sys.h"         //系统配置
  2. #include "delay.h"       //延时
  3. #include "usart.h"       //串口                 
  4. #include "led.h"      
  5. #include "ADS1292.h"
  6. #include "Timer.h"
  7. #include "dma.h"

  9. u8 xinlv;
  10. extern u8 xinlv1;
  11. s32 get_volt(u32 num);
  12. u8 flag;
  13. u16 flag1;
  14. //main
  15. int main(void)
  16. {       
  17.                 u8 res,i,sum;       
  18.                 u8 data_to_send[60];//串口发送缓存
  19.                 u8 usbstatus=0;       
  20.                 u32 cannle[2];        //存储两个通道的数据
  21.                 s32        p_Temp[2];        //数据缓存
  22.        
  23.                 data_to_send[0]=0xAA;
  24.                 data_to_send[1]=0xAA;
  25.                 data_to_send[2]=0xF1;       
  26.                 data_to_send[3]=8;
  27.                 data_to_send[13] = 0X0D;        //校验和
  28.                 data_to_send[14] = 0X0A;        //校验和

  30. //初始化系统时钟         72M       
  31.                 SystemInit();       
  32.                 delay_init();       
  33.                 delay_ms(100);
  34.                 uart1_init(500000);//串口初始化为115200               
  35.                 DMA_Config(DMA1_Channel4,(u32)&USART1->DR,(u32)data_to_send);//串口1DMA设置
  36.                 USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE); //DMA       
  37.                 LED_Init();                       

  39.                 ADS1292_Init();        //初始化ads1292                                       
  40.                 while(Set_ADS1292_Collect(0))
  41.                 {       
  42.                                 printf("1292寄存器设置失败\r\n");
  43.                                 delay_s(1);               

  45.                 }       
  46.                 printf("寄存器设置成功\r\n");
  47.                 delay_s(1);                       
  48.                 TIM2_Init(50,1439);//系统指示
  49.                 TIM4_Init(50,1439);//打印心率
  50.                
  51.                 EXTI->IMR |= EXTI_Line8;//开DRDY中断                       
  52.                 while(1)//循环发送数据               
  53.                 {                               
  54.                        
  55.                                 if(ads1292_recive_flag==1)
  56.                                 {               
  57.                                                 flag1++;                               
  58.                                                         cannle[0]=ads1292_Cache[3]<<16 | ads1292_Cache[4]<<8 | ads1292_Cache[5];//获取原始数据
  59.                                        
  60.                                                         cannle[1]=ads1292_Cache[6]<<16 | ads1292_Cache[7]<<8 | ads1292_Cache[8];  //
  61.                                                
  62.                                                         p_Temp[0] = get_volt(cannle[0]);        //把采到的3个字节转成有符号32位数
  63.                                        
  64.                                                         p_Temp[1] = get_volt(cannle[1]);        //把采到的3个字节转成有符号32位数
  65.                                        
  66.                
  67.                                                         cannle[0] = p_Temp[0];
  68.                                        
  69.                                                         cannle[1]        = p_Temp[1];
  70.                                                         data_to_send[4]=cannle[0]>>24;                //25-32位
  71.                                                         data_to_send[5]=cannle[0]>>16;          //17-24
  72.                                                         data_to_send[6]=cannle[0]>>8;                //9-16
  73.                                                         data_to_send[7]=cannle[0];                         //1-8

  75.                                                         data_to_send[8]=cannle[1]>>24;                //25-32位
  76.                                                         data_to_send[9]=cannle[1]>>16;          //17-24
  77.                                                         data_to_send[10]=cannle[1]>>8;                //9-16
  78.                                                         data_to_send[11]=cannle[1];                         //1-8
  79.                                                        
  80.                                                         for(i=0;i<12;i++)
  81.                                                                         sum += data_to_send[i];       
  82.        //       printf("%d\r\n",sum);                                                                               
  83.                                                         data_to_send[12] = sum;        //校验和                                                       
  84.                                         //                DMA_Enable(DMA1_Channel4,13);//串口1DMA
  85.                                                                                                                                                                
  86.                                                         ads1292_recive_flag=0;
  87.                                                         sum = 0;       
  88.                                                        
  89.                 if((p_Temp[1]>265000)&&(flag==1))       
  90.                         {
  91.                         xinlv++;               
  92.                                 flag=0;
  93.                         }
  94.                         else if((p_Temp[1]<265000)&&(flag==0))
  95.      flag=1;

  97.                                 }
  98.                                

  100.                 }               
  101. }


  104. /*功能：把采到的3个字节转成有符号32位数 */
  105. s32 get_volt(u32 num)
  106. {               
  107.                         s32 temp;                       
  108.                         temp = num;
  109.                         temp <<= 8;
  110.                         temp >>= 8;
  111.                         return temp;
  112. }

复制代码

Keil代码下载:
代码.7z (207.13 KB, 下载次数: 50)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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