dataproc.c

测量脉搏的源码 Cypress公司使用 CY27443 完成相关的功能

#include "PSoCApi.h"
#include <m8c.h>
#include "globdefs.h"
#include "utils.h"
#include "sigproc.h"




#define TIMER_PULSE_INIT_VALUE 190
static volatile BYTE timer_pulse = TIMER_PULSE_INIT_VALUE;

#define INITTIMER() {timer_pulse = TIMER_PULSE_INIT_VALUE;}
#define CHECKTIMER()(timer_pulse)

#define TIMER_UPDATE_INIT_VALUE 16
static volatile BYTE timer_update = TIMER_UPDATE_INIT_VALUE;


static BYTE state = RESET;
static BYTE index = 0;

#define MEDIAN_FILTER1_LENGHT 13
#define MEDIAN1 (MEDIAN_FILTER1_LENGHT >> 1)

#define MEDIAN_FILTER2_LENGHT 5
#define MEDIAN2 ((MEDIAN_FILTER2_LENGHT >> 1))

#if (MEDIAN_FILTER1_LENGHT > MEDIAN_FILTER2_LENGHT)
static PULSE_INTERVAL_TYPE pulse_buffer[MEDIAN_FILTER1_LENGHT];
#else 
static PULSE_INTERVAL_TYPE pulse_buffer[MEDIAN_FILTER2_LENGHT];
#endif

#if ((MEDIAN_FILTER1_LENGHT < 3) || (MEDIAN_FILTER2_LENGHT < 3))
#error "please set correct lenght for filters"
#endif

#pragma interrupt_handler SleepTimer_handler;
void SleepTimer_handler(void)
{
  if (TIMER_PULSE_INIT_VALUE == timer_pulse) SETBIT(LED_PORT, LED_BIT); else CLEARBIT(LED_PORT, LED_BIT);
  if (timer_pulse) timer_pulse--;
  
  if (timer_update) timer_update--;
}

BYTE Check_Update_Timeout(void)
{
  BYTE temp = 0;
  
  M8C_DisableGInt;
  if (!timer_update) 
  { 
    timer_update = TIMER_UPDATE_INIT_VALUE;
    temp = TRUE;
  }
  M8C_EnableGInt;
  
  return temp;
}

void median_filter(PULSE_INTERVAL_TYPE *buffer, BYTE len)
{
 PULSE_INTERVAL_TYPE temp;
 BYTE i, changed;

  do {
       changed = 0;
       for (i = 0; i < (len-1); i++)
        if (buffer[i] > buffer[i+1]) 
        {
           changed = 1;
           
           temp = buffer[i]; 
           buffer[i] = buffer[i+1];
           buffer[i+1] = temp;
        }
 } while (changed);
}

INT Pulse_Instant_Calculate(void)
{
  INT instant_pulse = GetPulseDelta();  

  if (instant_pulse)
  {
    INITTIMER();
    pulse_buffer[index++] = instant_pulse;
    
    if (MEDIAN_FILTER1_LENGHT == index)
    {
      index = 0;
      median_filter(pulse_buffer, MEDIAN_FILTER1_LENGHT);
      
      instant_pulse = pulse_buffer[MEDIAN1 + 1] - pulse_buffer[MEDIAN1 - 1];
      instant_pulse <<= 3;
      if (instant_pulse > pulse_buffer[MEDIAN1]) return PULSE_CALC_ERROR;
             
      instant_pulse = pulse_buffer[MEDIAN1] + pulse_buffer[MEDIAN1-1] + pulse_buffer[MEDIAN1+1];      
      return (LONG)(3*60*PULSE_ADC_SAMPLE_FREQ)/instant_pulse;
    }
      return PULSE_IN_PROGRESS;
  }
    else 
  if (CHECKTIMER()) return PULSE_IN_PROGRESS; else
  {
    index = 0;
    return PULSE_CALC_ERROR;   
  }
}

void Pulse_Init_Calculate(void)
{
  state = RESET;
  index = 0;
}


INT Pulse_Averaged_Calculate(void)
{
  static WORD total_intervals = 0;  
  static WORD pulses = 0;
  
  INT instant_pulse = GetPulseDelta();
  
  WORD med_buffer[MEDIAN_FILTER2_LENGHT], aver;
  BYTE i = MEDIAN_FILTER2_LENGHT;
  
  if (instant_pulse)
  {
    INITTIMER();
       
    switch (state)
    {
      case RESET: 
        pulses = total_intervals = index = 0;
        state = INITFILL;
        break;
      case INITFILL:  
        if ((MEDIAN_FILTER2_LENGHT-1) == index)
        {
          while(i--) med_buffer[i] = pulse_buffer[i];
          median_filter(med_buffer, MEDIAN_FILTER2_LENGHT);
          aver = med_buffer[MEDIAN_FILTER2_LENGHT >> 1];
       
          if ((instant_pulse > (aver -(aver >> 2))) && (instant_pulse < (aver + (aver >> 2)))) 
            state = RUNNING;
        } 
        break;
      case RUNNING:
        while(i--) med_buffer[i] = pulse_buffer[i];
        median_filter(med_buffer, MEDIAN_FILTER2_LENGHT);
        aver = med_buffer[MEDIAN_FILTER2_LENGHT >> 1];
      
        if ((instant_pulse > (aver -(aver >> 2))) && (instant_pulse < (aver + (aver >> 2)))) pulses++;
        
        total_intervals += instant_pulse; 
        if (total_intervals > PULSE_TIME_INTERVAL)
        { 
          state = RESET;
          return (PULSE_SCALE_FACTOR*pulses*PULSE_TIME_INTERVAL)/(long)total_intervals;
        }
        break;  
        
     default:
       state = RESET;
       break;
    }
    
    pulse_buffer[index++] = instant_pulse;
    if (index == MEDIAN_FILTER2_LENGHT) index = 0; 
  }
    else 
  if (!CHECKTIMER()) 
  {
    state = RESET;
    return PULSE_CALC_ERROR;   
  }  
    
  return PULSE_IN_PROGRESS;
}