WebSVN – libIgnTiming – Diff – /trunk/src/timing.cpp

 #include <cstdint>
 #include <assert.h>
 #include "libIgnTiming/timing.h"
+#include "libIgnTiming/basemap.h"
-#if !defined WRITABLE_TABLE
-#define CONST_ATTR constexpr
-#endif
 #if defined __cplusplus
 extern "C"
+{
 #endif
     namespace
+    {
         int8_t timingAdjust = 0 * TIMING_SCALE; // in TIMING_SCALE
-        unsigned constexpr INTERP_SCALE = 256;
+        // local copy of the data structure
-        int constexpr TimingScale = TIMING_SCALE;
+        timingTable_t timingMap = baseTimingMap;
-        int16_t constexpr NO_DATA = -1;
         int16_t constexpr MAX_ADVANCE = 50 * TIMING_SCALE;
         int16_t constexpr MIN_ADVANCE = 7 * TIMING_SCALE;
-        // array of column headings
-        int16_t CONST_ATTR rpmMap[MAX_RPM_POINTS] = {400, 750, 1000, 1500, 2500, 3500, 4500, 6000};
-        // column of row values - in 1000-pressure
-        int16_t CONST_ATTR vacuumMap[MAX_VACUUM_POINTS] = {0, 166, 225, 300, 700, 1000, NO_DATA, NO_DATA};
-        uint8_t CONST_ATTR mapping[MAX_VACUUM_POINTS][MAX_RPM_POINTS] = {
-            /* Table in degrees. */
-            /* row for 0mb = centrifugal only */
-            {12, 7, 7, 19, 25, 29, 29, 22},
-            /* row for 166 mB*/
-            {12, 7, 7, 21, 27, 31, 31, 24},
-            /*   row for 225 mB */
-            {12, 7, 7, 25, 31, 35, 35, 28},
-            /* row for 300 mB*/
-            {12, 7, 7, 29, 35, 39, 39, 33},
-            /* row for 700 mB*/
-            {12, 7, 7, 19, 25, 29, 29, 22},
-            /* row for 1000 mB - used when pressure drops off the scale */
-            {7, 7, 7, 7, 7, 7, 7, 7},
-            /* unused */
-            {0, 0, 0, 0, 0, 0, 0, 0},
-            /* unused */
-            {0, 0, 0, 0, 0, 0, 0, 0},
-            /* unused */
-        };
+    }
     uint8_t getTimingAdjust() { return timingAdjust; };
     void setTimingAdjust(int8_t adjust) { timingAdjust = adjust; }
     int16_t getRpmMap(unsigned int i)
+    {
         if (i >= 0 && i < MAX_RPM_POINTS)
-            return rpmMap[i];
+            return timingMap.rpmMap[i];
         else
             return 0;
+    }
+    void setBaseMap(timingTable_t * map)
+    {
+        timingMap = *map;
+    }
     void setRpmMap(unsigned int i, uint16_t val)
+    {
 #if WRITABLE_TABLE
         if (i >= 0 && i < MAX_RPM_POINTS)
-            rpmMap[i] = val;
+            timingMap.rpmMap[i] = val;
 #endif
+    }
     uint16_t getVacuumMap(unsigned int i)
+    {
         if (i >= 0 && i < MAX_VACUUM_POINTS)
-            return vacuumMap[i];
+            return timingMap.vacuumMap[i];
         else
             return 0;
+    }
     void setVacuumMap(unsigned int i, uint16_t val)
+    {
 #if WRITABLE_TABLE
         if (i >= 0 && i < MAX_VACUUM_POINTS)
-            vacuumMap[i] = val;
+            timingMap.vacuumMap[i] = val;
 #endif
+    }
     void setTiming(unsigned int vacuumIndex, unsigned int rpmIndex, uint8_t value)
+    {
 #if WRITABLE_TABLE
         if (vacuumIndex < 0 && vacuumIndex >= MAX_VACUUM_POINTS)
             return;
         if (rpmIndex < 0 && rpmIndex >= MAX_RPM_POINTS)
             return;
-        mapping[vacuumIndex][rpmIndex] = value;
+        timingMap.mapping[vacuumIndex][rpmIndex] = value;
 #endif
+    }
     uint8_t getTiming(unsigned int vacuumIndex, unsigned int rpmIndex)
+    {
         if (vacuumIndex < 0 && vacuumIndex >= MAX_VACUUM_POINTS)
             return 0;
         if (rpmIndex < 0 && rpmIndex >= MAX_RPM_POINTS)
             return 0;
-        return mapping[vacuumIndex][rpmIndex];
+        return timingMap.mapping[vacuumIndex][rpmIndex];
+    }
     /// @brief Lookup a point in a 1 dimensional array -
     /// @param point Value to lookup
     /// @param curve Lookup table
         int mapTiming(int rpm, int vacuumMb)
+        {
             int angle = 0;
             /* lookup the interpolated RPM point */
             int16_t rpm_frac = 0;
-            int rpm_index = lookup(rpm, rpmMap, MAX_RPM_POINTS, &rpm_frac);
+            int rpm_index = lookup(rpm, timingMap.rpmMap, MAX_RPM_POINTS, &rpm_frac);
             if (rpm_index == NO_DATA)
                 return timingAdjust + MIN_ADVANCE;
             /* lookup the interpolated vacuum point */
             int16_t vacuum_frac = 0;
-            int vacuum_index = lookup(vacuumMb, vacuumMap, MAX_VACUUM_POINTS, &vacuum_frac);
+            int vacuum_index = lookup(vacuumMb, timingMap.vacuumMap, MAX_VACUUM_POINTS, &vacuum_frac);
             /* if there is a problem, bail out */
             if (vacuum_index == NO_DATA)
                 return timingAdjust + MIN_ADVANCE;
             /* perform a bilinear mapping */
             int top_advance;
             // we now have a position between two points in X and Y
             if (rpm_frac == 0)
-                top_advance = mapping[vacuum_index][rpm_index] * INTERP_SCALE;
+                top_advance = timingMap.mapping[vacuum_index][rpm_index] * INTERP_SCALE;
             // if fractional part then interpolate points off the map
             else
-                top_advance = mapping[vacuum_index][rpm_index] * (INTERP_SCALE - rpm_frac) + mapping[vacuum_index][rpm_index + 1] * rpm_frac;
+                top_advance = timingMap.mapping[vacuum_index][rpm_index] * (INTERP_SCALE - rpm_frac) +
+                              timingMap.mapping[vacuum_index][rpm_index + 1] * rpm_frac;
             int bottom_advance;
             // if no fractional part, then the top and bottom advance point is the same
             if (vacuum_frac == 0)
+            {
-                angle = top_advance * TimingScale / INTERP_SCALE;
+                angle = top_advance * TIMING_SCALE / INTERP_SCALE;
+            }
             else
+            {
-                bottom_advance = mapping[vacuum_index + 1][rpm_index] * (INTERP_SCALE - rpm_frac) + mapping[vacuum_index + 1][rpm_index + 1] * rpm_frac;
+                bottom_advance = timingMap.mapping[vacuum_index + 1][rpm_index] * (INTERP_SCALE - rpm_frac) +
+                                 timingMap.mapping[vacuum_index + 1][rpm_index + 1] * rpm_frac;
                 /* interpolate down Y axis this time */
                 int advance = top_advance * (INTERP_SCALE - vacuum_frac) + bottom_advance * vacuum_frac;
                 /* point is scaled by two multiplications */
-                angle = advance * TimingScale / (INTERP_SCALE * INTERP_SCALE);
+                angle = advance * TIMING_SCALE / (INTERP_SCALE * INTERP_SCALE);
+            }
             if (angle < MIN_ADVANCE)
                 angle = MIN_ADVANCE;
             if (angle > MAX_ADVANCE)

Subversion Repositories libIgnTiming

(root)/trunk/src/timing.cpp – Rev 11 → 12