Subversion Repositories EDIS_Ignition

Rev

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