pixart_heart_rate_demo.cpp

00001 #include "pixart_heart_rate_demo.h"
00002 
00003 #include "system_clock.h"
00004 
00005 #include "pixart_heart_rate.h"
00006 #include "pixart_pah8011.h"
00007 
00008 
00009 namespace pixart {
00010     
00011     
00012     static Serial *pc = NULL;
00013     
00014     
00015     heart_rate_demo::heart_rate_demo(I2C &i2c, InterruptIn &interrupt, Serial &serial)
00016         : m_i2c(i2c)
00017         , m_interrupt(interrupt)
00018         , m_has_pah8011_interrupt(false)
00019         , m_pah8011_interrupt_timestamp(0)
00020     {
00021         pc = &serial;
00022     }
00023     
00024     void heart_rate_demo::run()
00025     {
00026         pc->printf("Pixart Demo HeartRate with PAH8011\n");
00027         
00028         // system clock
00029         system_clock_init();
00030         
00031         // interrupt
00032         m_interrupt.rise(this, &heart_rate_demo::pah8011_interrupt_handle);
00033         
00034         // heart_rate
00035         pixart::heart_rate heart_rate(heart_rate_demo::time_to_millisec);
00036         heart_rate.enable_debug_print(heart_rate_demo::debug_print);
00037         if (!heart_rate.init())
00038         {
00039             pc->printf("heart_rate.init() failed\n");
00040             error_handler();
00041         }
00042         
00043         // pah8011
00044         pixart::pah8011 pah8011(m_i2c);
00045         pah8011.enable_debug_print(heart_rate_demo::debug_print);
00046         if (!pah8011.init())
00047         {
00048             pc->printf("pah8011.init() failed\n");
00049             error_handler();
00050         }
00051         if (!pah8011.enable_ppg())
00052         {
00053             pc->printf("pah8011.enable_ppg() failed\n");
00054             error_handler();
00055         }
00056         
00057         while(true)
00058         {
00059             if (m_has_pah8011_interrupt)
00060             {
00061                 m_has_pah8011_interrupt = false;
00062             
00063                 if (!pah8011.task())
00064                 {
00065                     pc->printf("pah8011.task() failed\n");
00066                     error_handler();
00067                 }
00068             
00069                 pixart::pah8011::task_result result;
00070                 if (pah8011.get_result(result))
00071                 {
00072                     if (result.ch_num != 2)
00073                         error_handler();
00074                 
00075                     for (uint32_t i = 0; i < result.num_per_ch; ++i)
00076                     {
00077                         // set ppg sample
00078                         pixart::heart_rate::ppg_sample ppg_sample;
00079                         ppg_sample.ch1 = result.data[i * result.ch_num + 0];
00080                         ppg_sample.ch2 = result.data[i * result.ch_num + 1];
00081                         ppg_sample.is_touched = result.is_touched;
00082                         ppg_sample.timestamp = m_pah8011_interrupt_timestamp;
00083                         heart_rate.set_ppg_sample(ppg_sample);
00084                     
00085                         // set accel sample (dummy)
00086                         pixart::heart_rate::accel_sample accel_sample;
00087                         accel_sample.x = 0.0f;
00088                         accel_sample.y = 0.0f;
00089                         accel_sample.z = 0.0f;
00090                         accel_sample.timestamp = m_pah8011_interrupt_timestamp;
00091                         heart_rate.set_accel_sample(accel_sample);                
00092                     }
00093                 
00094                     pixart::heart_rate::result hr_result = heart_rate.get_result();
00095                     switch (hr_result.ret)
00096                     {
00097                     case pixart::heart_rate::ret_success:
00098                         pc->printf("hr = %d, hr_trust_level = %d\n", (int)hr_result.hr, hr_result.hr_trust_level);
00099                         break;
00100                         
00101                     case pixart::heart_rate::ret_no_touch:
00102                         pc->printf("no touch\n");
00103                         break;
00104                         
00105                     case pixart::heart_rate::ret_signal_poor:
00106                         pc->printf("signal is poor\n");
00107                         break;
00108                         
00109                     default:
00110                         pc->printf("heart_rate.get_result() failed, ret = %d\n", hr_result.ret);
00111                         error_handler();
00112                         break;
00113                     }
00114                 }
00115             }
00116         }
00117     }
00118     
00119     void heart_rate_demo::error_handler()
00120     {
00121         pc->printf("error_handler()!\n");
00122     
00123         while (true)
00124         {
00125         }
00126     }
00127 
00128     void heart_rate_demo::debug_print(const char *fmt, ...)
00129     {
00130         char msg[128];
00131         va_list marker;
00132         va_start(marker, fmt);
00133         vsprintf(msg, fmt, marker);
00134         va_end(marker);
00135         
00136         pc->printf(msg);
00137     }
00138     
00139     uint64_t heart_rate_demo::time_to_millisec(uint64_t time)
00140     {
00141         return system_clock_time_to_milliseconds(time);
00142     }
00143 
00144     void heart_rate_demo::pah8011_interrupt_handle(void)
00145     {
00146         m_has_pah8011_interrupt = true;
00147         m_pah8011_interrupt_timestamp = system_clock_get_tick();
00148     }
00149 
00150 }