Subversion Repositories EngineBay2

// with a dwell angle of 45 degrees , 4 cylinders and a maximum RPM of 5000

// freq = 5000/60 * 2 = 166Hz.

// the TIM2 counter counts in 10uS increments,

// Need to accumulate low level for a 400th of a second before accepting it as a pulse

#define ACCUM_MAX (RPM_COUNT_RATE / 400)

#define GLITCH_MAX (RPM_COUNT_RATE / 2000)

#define RPM_AVERAGE 4

// scale for filtered samples

#define Scale 1024.0

// Rev counter processing from original RevCounter Project

uint16_t RPM_Diff = 0;

uint16_t RPM_Count_Latch = 0;

// accumulators

uint16_t RPM_Pulsecount = 0;

unsigned int RPM_FilteredWidth = 0;

// last time we detected end of dwell i.e. ignition pulse

uint16_t last_dwell_end = 0;

uint16_t RPM_Period[RPM_AVERAGE];

unsigned int RPM_Period_Ptr = 0;

  // compute the timer values

  // snapshot timers

  unsigned short RPM_Pulsewidth;

  // current RPM pulse next slot index

  unsigned short RPM_Count_Val;

  // accumulator for pulse widths 

  static unsigned short RPM_Accumulator = ACCUM_MAX;

  // Next state of pulse high/low

  // Current state of pulse high/low

  static unsigned char RPM_State_Curr = 1;

  __disable_irq(); // copy the counter value

  RPM_Count_Val = RPM_Count;

  __enable_irq();

  // if there is only one entry, cannot get difference

  if (RPM_Count_Latch != RPM_Count_Val)

  {

    {

      unsigned int base_time;

      unsigned int new_time;

      // if we are at N-1, stop.

      unsigned int next_count = (RPM_Count_Latch + 1) % RPM_SAMPLES;

      if (next_count == RPM_Count_Val)

      {

        break; // completed loop

      }

      char pulse_level = (RPM_Time[RPM_Count_Latch] & RPM_FLAG) ? 1 : 0;

      base_time = RPM_Time[RPM_Count_Latch] & ~RPM_FLAG;

      new_time = RPM_Time[next_count] & ~RPM_FLAG;

      RPM_Count_Latch = next_count;

      RPM_Pulsewidth = new_time - base_time;

      if (pulse_level == 0 && (RPM_Pulsewidth > ACCUM_MAX))

        RPM_State = 1;

      if (pulse_level == 1)

        RPM_State = 0;  

#if 0

      RPM_State_Curr = RPM_State;

      // Count up/down

      if (pulse_level == 0)

      {

        if (RPM_Pulsewidth > RPM_Accumulator) // going to cross zero

        {

          RPM_State = 0;

          RPM_Accumulator = 0;

        }

        else

        {

          RPM_Accumulator -=  RPM_Pulsewidth;

        }

      }

      else

      {

        if (RPM_Accumulator + RPM_Pulsewidth > ACCUM_MAX)

        {

          RPM_Accumulator = ACCUM_MAX;

        }

        else

        {

          RPM_Accumulator += RPM_Pulsewidth;

        }

      }

#endif

      // low pulse has reached at least minimum width, count it.

      if ((RPM_State == 1) && (RPM_State_Curr == 0))

      {

        RPM_Diff = new_time - last_dwell_end;

        RPM_Period[RPM_Period_Ptr] = RPM_Diff;

        RPM_Period_Ptr = (RPM_Period_Ptr + 1) % RPM_AVERAGE;

        if (RPM_Pulsecount < RPM_AVERAGE)

          RPM_Pulsecount++; // count one pulse

        last_dwell_end = new_time;

      }

      RPM_State_Curr = RPM_State;

    }

  }

  if (RPM_Pulsecount == RPM_AVERAGE)

  {

    // now have time for N pulses in clocks

    // need to scale by 19.55: one unit is 19.55 RPM

    // 1Hz is 30 RPM

    int i;

    RPM_FilteredWidth = 0;

    for (i = 0; i < RPM_AVERAGE; i++)

      RPM_FilteredWidth += RPM_Period[i];

    Coded_RPM = (Scale * 30.0 * RPM_AVERAGE * RPM_COUNT_RATE) / (19.55 * RPM_FilteredWidth);

#if !defined MY_DEBUG

    // reset here unless we want to debug

    RPM_Pulsecount = 0;

#endif

  }