WebSVN – chibiosIgnition – Diff – /trunk/src/timer2.c

 #include "timer2.h"
 #define  MICROSECS_PULSE 10
 // with a dwell angle of 45 degrees , 4 cylinders and a maximum RPM of 5000
 // freq = 5000/60 * 2 = 166Hz. Because the breaker might bounce , we accept the
 // first pulse longer than 1/300 of a second as being a proper closure .
 // the TIM2 counter counts in 10uS increments,
 #define BREAKER_COUNT_MIN (1E6/(MICROSECS_PULSE * 300))
 uint16_t nominal  = 0;
 uint16_t phase10 = 100; // 10 degrees
 volatile uint16_t sampleCount = 0;
 uint16_t outSampleCount = 0;
 volatile uint16_t sampleBuff[SAMPLE_BUFF_SIZE];
-typedef enum { WAIT_GAP, SKIP_BOUNCE } sampleState_t ;
+typedef enum { WAIT_GAP, SKIP_BOUNCE, HAVE_SAMPLE } sampleState_t ;
 sampleState_t  sampleState = WAIT_GAP;
+// difference between samples
+volatile uint16_t deltaTime;
 uint16_t rpm;
 void initTimer2()
                         TIM_CR1_ARPE );
         /// pulse width 200 uS
         TIM2->CCR1 = 200/MICROSECS_PULSE;
-    TIM2->CCER =  TIM_CCER_CC1E | TIM_CCER_CC1P  ; //enabled and low
+    TIM2->CCER =  TIM_CCER_CC1E | TIM_CCER_CC1P  ; //enabled and active high
-    TIM2->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 |
+    TIM2->CCMR1 = TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 |
                            TIM_CCMR1_OC1PE ;
     TIM2->CR2 = TIM_CR2_MMS_1 ; // trigger out is 010 = update
 uint16_t getRPM(void)
+{
         return rpm;
+}
+uint16_t getDelta(void)
+{
+        return deltaTime;
+}
 uint16_t wrapIndex(uint16_t index)
+{
-        if (index > SAMPLE_BUFF_SIZE)
+        if (index >= SAMPLE_BUFF_SIZE)
                 index -= SAMPLE_BUFF_SIZE;
     return index;
+}
 // allows for wrapping
 uint16_t getSampleBuff(uint16_t index)
+{
+        chSysLock();
         return sampleBuff[wrapIndex(index)];
+        chSysUnlock();
+}
-// waits for ignition pulse , debounces readings
+// waits for ignition pulse , debounces readings,
+// returns the pulse time, skips debounce time
 uint16_t getNextPulse(void)
+{
-        static uint16_t lastVal = 0;
+        static uint16_t lastSampleIndex = 0;
-        uint16_t retVal ;
-        uint8_t done = 0;
-        while(done == 0)
+        while(1)
+        {
-                uint16_t diff;
-                // wait until there are enough samples
-                while(1)
-                {
-                        diff = sampleCount - outSampleCount;
-                        if(outSampleCount >= sampleCount)
+                        while (outSampleCount == sampleCount)
-                                diff = sampleCount - outSampleCount;
-                        else
-                                diff = SAMPLE_BUFF_SIZE + sampleCount - outSampleCount;
-                        if(diff > 1)
-                                break;
-                        chThdSleep(10);
+                                chThdSleep(10);
-                }
-                // pick the next out of gap sample
-                if(sampleState == WAIT_GAP)
-                {
-                        done = 1;
-                        retVal = getSampleBuff(outSampleCount);
-                }
-                // see how many samples are too close together
-                sampleState = SKIP_BOUNCE;
-                uint16_t endCount = sampleCount;
-                while((sampleState == SKIP_BOUNCE) && (outSampleCount != endCount))
-                {
                         uint16_t thisTime  = getSampleBuff(outSampleCount);
                         outSampleCount = wrapIndex(outSampleCount + 1);
-                        uint16_t nextTime = getSampleBuff(outSampleCount);
+                        while (outSampleCount == sampleCount)
+                                chThdSleep(10);
-                        uint16_t deltaTime;
+                        uint16_t nextTime = getSampleBuff(outSampleCount);
                         // calculate wrapped time delta : should be > than bounce time to allow
-                        if(nextTime > thisTime)
-                                deltaTime = nextTime - thisTime;
+                        uint16_t diffTime = nextTime - thisTime;
-                        else
-                                deltaTime = 65536 + nextTime - thisTime;
-                        if(deltaTime > BREAKER_COUNT_MIN)
+                        if(diffTime > BREAKER_COUNT_MIN)
+                        {
-                                sampleState = WAIT_GAP;
+                                lastSampleIndex = outSampleCount;
-                                break;
+                                return nextTime;
+                        }
-                }
+        }
+  return 0;
+}
+void processNextPulse(uint16_t retVal)
+{
+        static uint16_t lastVal = 0;
         // at this point we should try to phase lock
-    uint32_t period;
-    if(retVal > lastVal)
+    deltaTime = retVal - lastVal;
-        period = retVal - lastVal;
+    if(deltaTime > 10000)
-    else
+    {
-        period = 65536 + retVal - lastVal;
+        __asm(" BKPT #0");
+    }
     lastVal = retVal;
-    float nomRPM = 30E6 / (MICROSECS_PULSE * period) ;
+    float nomRPM = 30E6 / (MICROSECS_PULSE * deltaTime) ;
         rpm = rpm + (nomRPM -rpm)/10;
                 rpm = rpm + 1;
 //      rpm += delta / 256;
         adjustRPM();
+    }
-        return retVal;
-}
 // set the timing advance from reference to
 void setAdvance(int16_t deg10)
+{
         if(stat & TIM_SR_CC1IF)
+        {
                 TIM3->SR &= ~TIM_SR_CC1IF;
             uint16_t sample = TIM3->CCR1;
             sampleBuff[sampleCount++] = sample;
-            if (sampleCount > SAMPLE_BUFF_SIZE)
+            if (sampleCount >= SAMPLE_BUFF_SIZE)
                 sampleCount = 0;
+        }
+}

Subversion Repositories chibiosIgnition

(root)/trunk/src/timer2.c – Rev 8 → 11