標(biāo)題: stm32導(dǎo)航車max30102上傳整數(shù)型數(shù)據(jù)的源碼 [打印本頁]
作者: diyue95    時間: 2018-5-3 23:30
標(biāo)題: stm32導(dǎo)航車max30102上傳整數(shù)型數(shù)據(jù)的源碼
單片機(jī)源程序如下:
  1. #include "struct_all.h"
  2. #include "delay.h"
  3. #include "sys.h"
  4. #include "usart1_dma.h"

  6. #include "algorithm.h"
  7. #include "max30102.h"

  9. #include "myiic.h"
  10. #include "key.h"

  12. #define MAX_BRIGHTNESS 255

  14. uint32_t aun_ir_buffer[150]; //infrared LED sensor data
  15. uint32_t aun_red_buffer[150];  //red LED sensor data
  16. int32_t n_ir_buffer_length; //data length
  17. int32_t n_spo2;  //SPO2 value
  18. int8_t ch_spo2_valid;  //indicator to show if the SPO2 calculation is valid
  19. int32_t n_heart_rate; //heart rate value
  20. int8_t  ch_hr_valid;  //indicator to show if the heart rate calculation is valid
  21. uint8_t uch_dummy;

  23. int32_t hr_buf[16];
  24. int32_t hrSum;
  25. int32_t hrAvg;
  26. int32_t spo2_buf[16];
  27. int32_t spo2Sum;
  28. int32_t spo2Avg;
  29. int32_t spo2BuffFilled;
  30. int32_t hrBuffFilled;
  31. int32_t hrValidCnt = 0;
  32. int32_t spo2ValidCnt = 0;
  33. int32_t hrThrowOutSamp = 0;
  34. int32_t spo2ThrowOutSamp = 0;
  35. int32_t spo2Timeout = 0;
  36. int32_t hrTimeout = 0;



  40. void Send_To_PC( int rate, int spo2 );
  41. void Send_To_PC2( unsigned int red, unsigned int ir);
  42. void loop(void);
  43. int main(void)
  44. {
  45.     uart1_tx.buf[0] = 0x55;
  46.     uart1_tx.buf[1] = 0xAA;
  47.     uart1_tx.buf[10] = 0x0D;
  48.     delay_init();                            //延時函數(shù)初始化
  49.     NVIC_Configuration();
  50.     USART1_DMA_Init(115200);    //PA9:TX  PA10:RX        接WIFI模塊         與手機(jī)相連發(fā)送狀態(tài)數(shù)據(jù)

  52.     KEY_Init();                                  //實(shí)際是  max30102的中斷線

  54.     bsp_InitI2C();
  55.     maxim_max30102_reset(); //resets the MAX30102

  57.     //pinMode(2, INPUT);  //pin D2 connects to the interrupt output pin of the MAX30102

  59.     maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_dummy); //Reads/clears the interrupt status register
  60.     maxim_max30102_init();  //initialize the MAX30102
  61.     while(1)
  62.     {
  63.          loop();
  64.     }
  65. }


  68. // the loop routine runs over and over again forever:
  69. void loop(void)
  70. {
  71.     uint32_t un_min, un_max, un_prev_data, un_brightness;  //variables to calculate the on-board LED brightness that reflects the heartbeats
  72.     int32_t i;
  73.     float f_temp;

  75.     un_brightness = 0;
  76.     un_min = 0x3FFFF;
  77.     un_max = 0;

  79.     n_ir_buffer_length = 150; //buffer length of 150 stores 3 seconds of samples running at 50sps

  81.     //read the first 150 samples, and determine the signal range
  82.     for(i = 0; i < n_ir_buffer_length; i++)
  83.     {
  84.         while(KEY0 == 1); //wait until the interrupt pin asserts
  85.         maxim_max30102_read_fifo((aun_red_buffer + i), (aun_ir_buffer + i)); //read from MAX30102 FIFO

  87.         if(un_min > aun_red_buffer[i])
  88.             un_min = aun_red_buffer[i]; //update signal min
  89.         if(un_max < aun_red_buffer[i])
  90.             un_max = aun_red_buffer[i]; //update signal max
  91.         /*SerialUSB.print(F("red="));
  92.         SerialUSB.print(aun_red_buffer[i], DEC);
  93.         SerialUSB.print(F(", ir="));
  94.         SerialUSB.println(aun_ir_buffer[i], DEC);*/
  95.                 //Send_To_PC2(aun_red_buffer[i],aun_ir_buffer[i]);
  96.     }
  97.     un_prev_data = aun_red_buffer[i];
  98.     //calculate heart rate and SpO2 after first 150 samples (first 3 seconds of samples)
  99.     maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_spo2, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);

  101.     //Continuously taking samples from MAX30102.  Heart rate and SpO2 are calculated every 1 second
  102.     while(1)
  103.     {
  104.         i = 0;
  105.         un_min = 0x3FFFF;
  106.         un_max = 0;

  108.         //dumping the first 50 sets of samples in the memory and shift the last 100 sets of samples to the top
  109.         for(i = 50; i < 150; i++)
  110.         {
  111.             aun_red_buffer[i - 50] = aun_red_buffer[i];
  112.             aun_ir_buffer[i - 50] = aun_ir_buffer[i];

  114.             //update the signal min and max
  115.             if(un_min > aun_red_buffer[i])
  116.                 un_min = aun_red_buffer[i];
  117.             if(un_max < aun_red_buffer[i])
  118.                 un_max = aun_red_buffer[i];
  119.         }

  121.         //take 50 sets of samples before calculating the heart rate.
  122.         for(i = 100; i < 150; i++)
  123.         {
  124.             un_prev_data = aun_red_buffer[i - 1];
  125.             while(KEY0 == 1);
  126.             maxim_max30102_read_fifo((aun_red_buffer + i), (aun_ir_buffer + i));

  128.             //calculate the brightness of the LED
  129.             if(aun_red_buffer[i] > un_prev_data)
  130.             {
  131.                 f_temp = aun_red_buffer[i] - un_prev_data;
  132.                 f_temp /= (un_max - un_min);
  133.                 f_temp *= MAX_BRIGHTNESS;
  134.                 f_temp = un_brightness - f_temp;
  135.                 if(f_temp < 0)
  136.                     un_brightness = 0;
  137.                 else
  138.                     un_brightness = (int)f_temp;
  139.             }
  140.             else
  141.             {
  142.                 f_temp = un_prev_data - aun_red_buffer[i];
  143.                 f_temp /= (un_max - un_min);
  144.                 f_temp *= MAX_BRIGHTNESS;
  145.                 un_brightness += (int)f_temp;
  146.                 if(un_brightness > MAX_BRIGHTNESS)
  147.                     un_brightness = MAX_BRIGHTNESS;
  148.             }
  149.                         //Send_To_PC2( aun_red_buffer[i], aun_ir_buffer[i] );
  150.             //send samples and calculation result to terminal program through UART
  151.             /*SerialUSB.print(F("red="));
  152.             SerialUSB.print(aun_red_buffer[i], DEC);
  153.             SerialUSB.print(F(", ir="));
  154.             SerialUSB.print(aun_ir_buffer[i], DEC);

  156.             SerialUSB.print(F(", HR="));
  157.             SerialUSB.print(n_heart_rate, DEC);

  159.             SerialUSB.print(F(", HRvalid="));
  160.             SerialUSB.print(ch_hr_valid, DEC);

  162.             SerialUSB.print(F(", SPO2="));
  163.             SerialUSB.print(n_spo2, DEC);

  165.             SerialUSB.print(F(", SPO2Valid="));
  166.             SerialUSB.println(ch_spo2_valid, DEC);*/

  168.             //      SerialUSB.println(aun_ir_buffer[i], DEC);
  169.         }
  170.         maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_spo2, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);

  172.         if ((ch_hr_valid == 1) && (n_heart_rate < 190) && (n_heart_rate > 40))
  173.         {
  174.             hrTimeout = 0;

  176.             // Throw out up to 1 out of every 5 valid samples if wacky
  177.             if (hrValidCnt == 4)
  178.             {
  179.                 hrThrowOutSamp = 1;
  180.                 hrValidCnt = 0;
  181.                 for (i = 12; i < 16; i++)
  182.                 {
  183.                     if (n_heart_rate < hr_buf[i] + 10)
  184.                     {
  185.                         hrThrowOutSamp = 0;
  186.                         hrValidCnt   = 4;
  187.                     }
  188.                 }
  189.             }
  190.             else
  191.             {
  192.                 hrValidCnt = hrValidCnt + 1;
  193.             }

  195.             if (hrThrowOutSamp == 0)
  196.             {

  198.                 // Shift New Sample into buffer
  199.                 for(i = 0; i < 15; i++)
  200.                 {
  201.                     hr_buf[i] = hr_buf[i + 1];
  202.                 }
  203.                 hr_buf[15] = n_heart_rate;

  205.                 // Update buffer fill value
  206.                 if (hrBuffFilled < 16)
  207.                 {
  208.                     hrBuffFilled = hrBuffFilled + 1;
  209.                 }

  211.                 // Take moving average
  212.                 hrSum = 0;
  213.                 if (hrBuffFilled < 2)
  214.                 {
  215.                     hrAvg = 0;
  216.                 }
  217.                 else if (hrBuffFilled < 4)
  218.                 {
  219.                     for(i = 14; i < 16; i++)
  220.                     {
  221.                         hrSum = hrSum + hr_buf[i];
  222.                     }
  223.                     hrAvg = hrSum >> 1;
  224.                 }
  225.                 else if (hrBuffFilled < 8)
  226.                 {
  227.                     for(i = 12; i < 16; i++)
  228.                     {
  229.                         hrSum = hrSum + hr_buf[i];
  230.                     }
  231.                     hrAvg = hrSum >> 2;
  232.                 }
  233.                 else if (hrBuffFilled < 16)
  234.                 {
  235.                     for(i = 8; i < 16; i++)
  236.                     {
  237.                         hrSum = hrSum + hr_buf[i];
  238.                     }
  239.                     hrAvg = hrSum >> 3;
  240.                 }
  241.                 else
  242.                 {
  243.                     for(i = 0; i < 16; i++)
  244.                     {
  245.                         hrSum = hrSum + hr_buf[i];
  246.                     }
  247.                     hrAvg = hrSum >> 4;
  248.                 }
  249.             }
  250.             hrThrowOutSamp = 0;
  251.         }
  252.         else
  253.         {
  254.             hrValidCnt = 0;
  255.             if (hrTimeout == 4)
  256.             {
  257.                 hrAvg = 0;
  258.                 hrBuffFilled = 0;
  259.             }
  260.             else
  261.             {
  262.                 hrTimeout++;
  263.             }
  264.         }

  266.         if ((ch_spo2_valid == 1) && (n_spo2 > 59))
  267.         {
  268.             spo2Timeout = 0;

  270.             // Throw out up to 1 out of every 5 valid samples if wacky
  271.             if (spo2ValidCnt == 4)
  272.             {
  273.                 spo2ThrowOutSamp = 1;
  274.                 spo2ValidCnt = 0;
  275.                 for (i = 12; i < 16; i++)
  276.                 {
  277.                     if (n_spo2 > spo2_buf[i] - 10)
  278.                     {
  279.                         spo2ThrowOutSamp = 0;
  280.                         spo2ValidCnt   = 4;
  281.                     }
  282.                 }
  283.             }
  284.             else
  285.             {
  286.                 spo2ValidCnt = spo2ValidCnt + 1;
  287.             }

  289.             if (spo2ThrowOutSamp == 0)
  290.             {

  292.                 // Shift New Sample into buffer
  293.                 for(i = 0; i < 15; i++)
  294.                 {
  295.                     spo2_buf[i] = spo2_buf[i + 1];
  296.                 }
  297.                 spo2_buf[15] = n_spo2;

  299.                 // Update buffer fill value
  300.                 if (spo2BuffFilled < 16)
  301.                 {
  302.                     spo2BuffFilled = spo2BuffFilled + 1;
  303.                 }

  305.                 // Take moving average
  306.                 spo2Sum = 0;
  307.                 if (spo2BuffFilled < 2)
  308.                 {
  309.                     spo2Avg = 0;
  310.                 }
  311.                 else if (spo2BuffFilled < 4)
  312.                 {
  313.                     for(i = 14; i < 16; i++)
  314.                     {
  315.                         spo2Sum = spo2Sum + spo2_buf[i];
  316.                     }
  317.                     spo2Avg = spo2Sum >> 1;
  318.                 }
  319.                 else if (spo2BuffFilled < 8)
  320.                 {
  321.                     for(i = 12; i < 16; i++)
  322.                     {
  323.                         spo2Sum = spo2Sum + spo2_buf[i];
  324.                     }
  325.                     spo2Avg = spo2Sum >> 2;
  326.                 }
  327.                 else if (spo2BuffFilled < 16)
  328.                 {
  329.                     for(i = 8; i < 16; i++)
  330.                     {
  331.                         spo2Sum = spo2Sum + spo2_buf[i];
  332.                     }
  333.                     spo2Avg = spo2Sum >> 3;
  334.                 }
  335.                 else
  336.                 {
  337.                     for(i = 0; i < 16; i++)
  338.                     {
  339.                         spo2Sum = spo2Sum + spo2_buf[i];
  340.                     }
  341.                     spo2Avg = spo2Sum >> 4;
  342.                 }
  343.             }
  344.             spo2ThrowOutSamp = 0;
  345.         }
  346.         else
  347.         {
  348.             spo2ValidCnt = 0;
  349.             if (spo2Timeout == 4)
  350.             {
  351.                 spo2Avg = 0;
  352.                 spo2BuffFilled = 0;
  353.             }
  354.             else
  355.             {
  356.                 spo2Timeout++;
  357.             }
  358.         }

  360.         Send_To_PC(hrAvg, spo2Avg);
  361.     }
  362. }







  370. /**
  371. * @Description: wifi發(fā)送到手機(jī)APP的數(shù)據(jù)，連接在uart1上
  372. * @param  encoder_left - 左輪編碼器值
  373. * @param  encoder_right- 右輪編碼器值
  374. * @note1  :數(shù)據(jù)協(xié)議   0xFFD8 左輪速度double型(8位)   右輪速度double型(8)位 數(shù)據(jù)個數(shù) 0xFFD9
  375. */
  376. union INT_CHAR
  377. {
  378.     char                     char_buf[4];
  379.     signed int       int_buf;                  //車輪的實(shí)際速度   單位：脈沖/s
  380. }int_char;
  381. void Send_To_PC( int rate, int spo2 )
  382. {
  383.     u8 i;
  384.     uart1_tx.buf[0] = 0xFF;
  385.     uart1_tx.buf[1] = 0xD8;
  386.         int_char.int_buf = rate;
  387.         for (i=0;i<4;i++)
  388.         {
  389.                 uart1_tx.buf[i+2] = int_char.char_buf[3-i];        //注意需要倒著發(fā)送
  390.         }
  391.         int_char.int_buf = spo2;
  392.         for (i=0;i<4;i++)
  393.         {
  394.                 uart1_tx.buf[i+6] = int_char.char_buf[3-i];        //注意需要倒著發(fā)送
  395.         }
  396.     uart1_tx.buf[10] = 0xFF;
  397.     uart1_tx.buf[11] = 0xD9;
  398.     USART1_DMA_Send_Once_Data( uart1_tx.buf, 12 );
  399. }

  401. union UNINT_CHAR
  402. {
  403.     char                     char_buf[4];
  404.     unsigned int     unint_buf;                  //車輪的實(shí)際速度   單位：脈沖/s
  405. }unint_char;
  406. void Send_To_PC2( unsigned int red, unsigned int ir)
  407. {
  408.     u8 i;
  409.     uart1_tx.buf[0] = 0xFF;
  410.     uart1_tx.buf[1] = 0xD8;
  411.         unint_char.unint_buf = red;
  412.         for (i=0;i<4;i++)
  413.         {
  414.                 uart1_tx.buf[i+2] = unint_char.char_buf[3-i];        //注意需要倒著發(fā)送
  415.         }
  416.         unint_char.unint_buf = ir;
  417.         for (i=0;i<4;i++)
  418.         {
  419.                 uart1_tx.buf[i+6] = unint_char.char_buf[3-i];        //注意需要倒著發(fā)送
  420.         }
  421.     uart1_tx.buf[10] = 0xFF;
  422.     uart1_tx.buf[11] = 0xD9;
  423.     USART1_DMA_Send_Once_Data( uart1_tx.buf, 12 );
  424. }
  425. ……………………

  427. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復(fù)制代碼

所有資料51hei提供下載:
stm32 max30102上傳整數(shù)型數(shù)據(jù).rar (337.99 KB, 下載次數(shù): 22)


作者: 有八塊腹肌的魚    時間: 2018-5-8 11:19
功能是實(shí)現(xiàn)什么的
作者: 迪佳豆    時間: 2021-3-18 12:50
int32_t hrValidCnt = 0;
int32_t spo2ValidCnt = 0;
int32_t hrThrowOutSamp = 0;
int32_t spo2ThrowOutSamp = 0;
int32_t spo2Timeout = 0;
int32_t hrTimeout = 0;  樓主，這些變量不是很懂，可以解釋一下嗎



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