Subversion Repositories EDIS_Ignition

Rev

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