Subversion Repositories EDIS_Ignition

Rev

Rev 10 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2.  
  3. #include "saveTiming.h"
  4.  
  5. #include "nvram.h"
  6. #include "main.h"
  7.  
  8. #include "libIgnTiming/timing.H"
  9.  
  10. // define tags for items
  11. static const uint8_t TIMING_OFFSET_TAG = 1; // timing offset tag
  12. static const uint8_t TIMING_LOW_TAG = 0x10;
  13. static const uint8_t VACUUM_LOW_TAG = 0x30;
  14. static const uint8_t MAP_BASE_TAG = 0x50;
  15. static const uint8_t MAP_ROW_OFFSET = 0x10;
  16. static const uint8_t UINT16_LOW_OFFSET = 0x10;
  17. static const uint8_t UINT16_HIGH_OFFSET = 0x00; // nothing but it looks tidier
  18.  
  19. /// @brief Load 16 bit data from two tagged byte items
  20. /// @param baseTag Tag to use for indexing
  21. /// @param data pointer to data to load value into
  22. /// @return true if succeeded
  23. static uint8_t load_uint16_t(uint8_t baseTag, uint16_t *data)
  24. {
  25.     nvram_info_t *found_high = find_nvram_data(baseTag+ UINT16_HIGH_OFFSET);
  26.     if (!found_high)
  27.         return 0;
  28.     nvram_info_t *found_low = find_nvram_data(baseTag + UINT16_LOW_OFFSET);
  29.     if (found_low)
  30.         return 0;
  31.     *data = (found_high->data.val << 8) | (found_low->data.val);
  32.     return 1;
  33. }
  34.  
  35. /// @brief Save 16 bit data in two tagged byte items
  36. /// @param baseTag
  37. /// @param data data to write
  38. static void save_uint16_t(uint8_t baseTag, uint16_t data)
  39. {
  40.     nvram_info_t info;
  41.     info.data.tag = baseTag + UINT16_HIGH_OFFSET;
  42.     info.data.val = data >> 8;
  43.     write_nvram_data(info);
  44.     info.data.tag = baseTag + UINT16_LOW_OFFSET;
  45.     info.data.val = data & 0xFF;
  46.     write_nvram_data(info);
  47. }
  48.  
  49. ///@brief load the timing info in from NVRAM
  50. void loadTimingInfoFromNvram()
  51. {
  52.     uint8_t missingData = 0;
  53.  
  54.     nvram_info_t *found = find_nvram_data(TIMING_OFFSET_TAG);
  55.     if (found)
  56.         setTimingAdjust(found->data.val);
  57.     else
  58.         missingData = 1;
  59.  
  60.     // load in timing map column heading values
  61.     for (int i = 0; i < MAX_RPM_POINTS; i++)
  62.     {
  63.         uint16_t val;
  64.         uint8_t found = load_uint16_t(TIMING_LOW_TAG + i, &val);
  65.         if (found)
  66.             setRpmMap(i, val);
  67.         else
  68.             missingData = 1;
  69.     }
  70.  
  71.     // load in vacuum map row heading values
  72.     for (int i = 0; i < MAX_VACUUM_POINTS; i++)
  73.     {
  74.         uint16_t val;
  75.         uint8_t found = load_uint16_t(VACUUM_LOW_TAG + i, &val);
  76.         if (found)
  77.             setVacuumMap(i, val);
  78.         else
  79.             missingData = 1;
  80.     }
  81.  
  82.     for (int i = 0; i < MAX_VACUUM_POINTS; i++)
  83.     {
  84.         uint8_t tag_base = i * MAP_ROW_OFFSET + MAP_BASE_TAG;
  85.         for (int j = 0; j < MAX_RPM_POINTS; j++)
  86.         {
  87.             found = find_nvram_data(tag_base + j);
  88.             if (found)
  89.                 setTiming(i, j, found->data.val);
  90.             else
  91.                 missingData = 1;
  92.         }
  93.     }
  94.  
  95.     if (missingData)
  96.         saveTimingInfoToNvram();
  97. }
  98.  
  99. /// @brief Save timing info to NVRAM : this relies on the
  100. void saveTimingInfoToNvram()
  101. {
  102.     nvram_info_t info;
  103.     info.data.tag = TIMING_OFFSET_TAG;
  104.     info.data.val = getTimingAdjust();
  105.     watchdogWrite();
  106.     write_nvram_data(info);
  107.  
  108.        // load in timing map column heading values
  109.     for (int i = 0; i < MAX_RPM_POINTS; i++)
  110.     {
  111.         uint16_t val = getRpmMap(i);
  112.         save_uint16_t(TIMING_LOW_TAG + i, val);
  113.     }
  114.  
  115.     // load in vacuum map row heading values
  116.     for (int i = 0; i < MAX_VACUUM_POINTS; i++)
  117.     {
  118.         uint16_t val = getVacuumMap(i);
  119.         watchdogWrite();
  120.         save_uint16_t(VACUUM_LOW_TAG + i, val);
  121.     }
  122.  
  123.     // save all the data values
  124.     for (int i = 0; i < MAX_VACUUM_POINTS; i++)
  125.     {
  126.         uint8_t tag_base = i * MAP_ROW_OFFSET+MAP_BASE_TAG;
  127.         for (int j = 0; j < MAX_RPM_POINTS; j++)
  128.         {
  129.             info.data.val = getTiming(i,j);
  130.             info.data.tag = tag_base + j;
  131.             watchdogWrite();
  132.             write_nvram_data(info);
  133.            
  134.         }
  135.     }
  136. }