File content as of revision 3:d3a1fc19bee6:

#include "mbed.h"
#include "OB1203.h"
#include "math.h"


#define intb_pin D3


I2C i2c(I2C_SDA,I2C_SCL);
InterruptIn intb(intb_pin);
DigitalOut sda_pullup(D11,1);
DigitalOut scl_pullup(D12,1);
DigitalOut intb_pullup(D13,1);

OB1203 ob1203(&i2c);
Serial pc(USBTX, USBRX,256000);
Timer t;

int sample_delay = 25; //ms


bool mode = 1; //0 for PS_LS, 1 for PPG
bool spo2 = 1; //0 for HR, 1 for SpO2
bool intFlagged =0;


void defaultConfig()
{
    ob1203.ls_rate = LS_RATE(2); //100ms
    ob1203.ls_res = LS_RES(2); //18bit 100ms
    ob1203.ls_gain = LS_GAIN(1); //gain 3 default (range)
    ob1203.ls_thres_hi = 0x000FFFFF;
    ob1203.ls_thres_lo = 0;
    ob1203.ls_sai = LS_SAI_OFF;
    ob1203.ls_mode = RGB_MODE;
    ob1203.ls_en = LS_ON;
    
    ob1203.ps_sai_en = PS_SAI_OFF;
    if(mode)
    {
        if (spo2)
        {
            ob1203.ppg_ps_mode = SPO2_MODE;
        }
        else
        {
            ob1203.ppg_ps_mode = HR_MODE;    
        }
        
    }
    else
    {
        ob1203.ppg_ps_mode = PS_MODE;
    }
    ob1203.ps_pulses = PS_PULSES(2);
//    pc.printf("ps_pulses = %02X\r\n",ob1203.ps_pulses);
    ob1203.ps_pwidth = PS_PWIDTH(4);
    ob1203.ps_rate = PS_RATE(3);
//    pc.printf("ps_rate = %02X\r\n",ob1203.ps_rate);
    ob1203.ps_avg_en = PS_AVG_OFF;
    ob1203.ps_can_ana = PS_CAN_ANA_0;
    ob1203.ps_digital_can = 0;
    ob1203.ps_hys_level = 0;
    ob1203.ps_current = 0x3FF;
    ob1203.ps_thres_hi = 0xFF;
    ob1203.ps_thres_lo = 0x00;
    
    //interrupts
    ob1203.ls_int_sel = LS_INT_SEL_W;
    ob1203.ls_var_mode = LS_THRES_INT_MODE;
    ob1203.ls_int_en = LS_INT_ON;
    ob1203.ppg_ps_en = PPG_PS_ON;
    ob1203.afull_int_en = AFULL_INT_ON;
    ob1203.ppg_int_en = PPG_INT_OFF;
    ob1203.ps_logic_mode = PS_INT_READ_CLEARS;
    ob1203.ps_int_en = PS_INT_ON;
    ob1203.ls_persist = LS_PERSIST(2);
    ob1203.ps_persist = PS_PERSIST(2);

    //PPG
    ob1203.ir_current = 0x1FF;
    if (spo2)
    {
        ob1203.r_current = 0x1FF;
    }
    else 
    {   
        ob1203.r_current = 0;
    }
    ob1203.ppg_ps_gain = PPG_PS_GAIN_2;
    ob1203.ppg_pow_save = PPG_POW_SAVE_OFF;
    ob1203.led_flip = LED_FLIP_OFF;
    ob1203.ch1_can_ana = PPG_CH1_CAN(0);
    ob1203.ch2_can_ana = PPG_CH2_CAN(0);
    ob1203.ppg_avg = PPG_AVG(3);
    ob1203.ppg_rate = PPG_RATE(1);
    ob1203.ppg_pwidth = PPG_PWIDTH(3);
    ob1203.ppg_freq = PPG_FREQ_60HZ;
//    ob1203.ppg_freq = PPG_FREQ_50HZ;

    ob1203.fifo_rollover_en = FIFO_ROLL_ON;
    ob1203.fifo_afull_samples_left = AFULL_SAMPLES_LEFT(8);

    if(mode)
    {
        if(spo2)
        {
            ob1203.init_spo2();
        }
        else
        {
            ob1203.init_hr();
        }
    }
    else    
    {
        ob1203.init_ps_rgb();
    }
}

void regDump(uint8_t Addr, uint8_t startByte, uint8_t endByte)
{
    /*print the values of up to 20 registers--buffer limit, e.g.*/
    char regData[20];
    int numBytes;
    if (endByte>=startByte) {
        numBytes =  (endByte-startByte+1) < 20 ? (endByte-startByte+1) : 20;
    } else {
        numBytes=1;
    }

    regData[0] = startByte;
    i2c.write(Addr,regData,1,true);
    i2c.read(Addr, regData, numBytes);
    for(int n=0; n<numBytes; n++) {
        pc.printf("%02X, %02X \r\n", startByte+n, regData[n]);
    }
}


void intEvent(void)
{
    intFlagged = 1;
}

int main() 
{
    uint32_t running_avg = 8;
    char avg_ptr = 0;
    int first = 1;
    uint32_t IRavg = 0;
    uint32_t Ravg = 0;
    uint32_t IRprev = 0;
    uint32_t Rprev = 0;
    uint32_t prevAvg = 0;
    uint32_t IR_avg_buffer[running_avg];
    uint32_t R_avg_buffer[running_avg];
    i2c.frequency( 400000 );
    char valid;
    uint32_t ps_ls_data[6];
    char samples2Read = 4; //samples, e.g. 4 samples * 3 bytes = 12 bytes (or 2 SpO2 samples)
    char fifoBuffer[samples2Read*3];
    uint32_t ppgData[samples2Read];  

    
    pc.printf("register settings\r\n");
    regDump(OB1203_ADDR,0,19);
    regDump(OB1203_ADDR,20,39);
    regDump(OB1203_ADDR,40,59);
    regDump(OB1203_ADDR,60,77);
    
    pc.printf("do initial config\r\n");
    defaultConfig(); //rgb ps
    
    pc.printf("print new register config\r\n");
    regDump(OB1203_ADDR,0,19);
    regDump(OB1203_ADDR,20,39);
    regDump(OB1203_ADDR,40,59);
    regDump(OB1203_ADDR,60,77);
    
        
    intb.fall(&intEvent);
    t.start();
    while(1)
    {
        if(mode)
        {
            if(!intb.read())
            {
                intFlagged = 1;
            }
            if(intFlagged)
            {
                
                ob1203.getFifoSamples(samples2Read,fifoBuffer);
//                for (int n=0;n<samples2Read*3;n++)
//                {
//                    pc.printf("%02X ",fifoBuffer[n]);
//                }
//                pc.printf("\r\n");
                ob1203.parseFifoSamples(samples2Read,fifoBuffer,ppgData);
//                for (int n=0;n<samples2Read;n++)
//                {
//                    pc.printf("%d ",ppgData[n]);
//                }
//                pc.printf("\r\n");
                if(first) //populate average buffers the first time we run
                {
                    for(int n=0;n<running_avg;n++)
                    {
                        IR_avg_buffer[n] = ppgData[0];
                        IRavg += IR_avg_buffer[n];
                        if(spo2)
                        {
                            R_avg_buffer[n] = ppgData[1];
                            Ravg += R_avg_buffer[n];
                        }
                        
                    }
                    first = 0;
                }
                                
                for (int n=0;n<samples2Read/2;n++)
                {
                    ( avg_ptr+1 == running_avg ) ? avg_ptr = 0 : avg_ptr++;
                    IRprev = IR_avg_buffer[avg_ptr]; //load the sample you are about to write over
                    IR_avg_buffer[avg_ptr] = ppgData[2*n]; //load the new sample in the buffer
                    IRavg += (IR_avg_buffer[avg_ptr] - IRprev); //update the average by removing the old sample and adding the new
                    if(spo2)
                    {
                        Rprev = R_avg_buffer[avg_ptr];
                        R_avg_buffer[avg_ptr] = ppgData[2*n+1];
                        Ravg += (R_avg_buffer[avg_ptr] - Rprev);
                        //                        pc.printf("%d, %d, %d\r\n",t.read_us(),ppgData[2*n],ppgData[2*n+1]);
//                        pc.printf("%d, %d, %d, %d\r\n",IRavg/running_avg,Ravg/running_avg, IR_avg_buffer[avg_ptr],R_avg_buffer[avg_ptr]);
                        pc.printf("%d,%d\r\n",IRavg/running_avg,Ravg/running_avg);
                    }
                    else
                    {
                        ( avg_ptr+1 == running_avg ) ? avg_ptr = 0 : avg_ptr++;
                        IRprev = IR_avg_buffer[avg_ptr];
                        IR_avg_buffer[avg_ptr] = ppgData[2*n+1];
                        prevAvg = IRavg;
                        IRavg += (IR_avg_buffer[avg_ptr] - IRprev);
                        pc.printf("%d\r\n%d\r\n",prevAvg/running_avg,IRavg/running_avg);
//                        pc.printf("%d\r\n%d\r\n",ppgData[2*n],ppgData[2*n+1]);
                        
                    }
                }
                intFlagged = 0;   
        
            }
        }
        else
        {
            wait_ms(sample_delay);
            if(ob1203.dataIsNew())
            {
                valid = ob1203.get_ps_ls_data(ps_ls_data);
                pc.printf("%d %d %d %d %d %d\r\n",ps_ls_data[0],ps_ls_data[1],ps_ls_data[2],ps_ls_data[3],ps_ls_data[4],ps_ls_data[5]);
            }
//            else
//            {
//                pc.printf("status = %04X\r\n",ob1203.get_status() );
//            }
        }
    }//end while
}//end main