Updated memory storage functionality

- cachedStorage is functional
- Presets can be loaded from FLASH
- CRC32 added and applied
- Presets with corrputed data will be replaced by default preset

Next: Preset update functionality from menu 

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@269 05563f52-14a8-4384-a975-3d1654cca0fa

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/Makefile

@@ -26,6 +26,7 @@ OBJECTS = \
 ADCDevice.o \
 CachedStorage.o \
 CoverSolenoid.o \
+crc32.o \
 DACDevice.o \
 DisplayDevice.o \
 hsb-mrts.o \

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/CachedStorage.h

@@ -52,12 +52,12 @@
 struct CachedStorage
 {
    bool initialized;
-   unsigned int pageSize;
+   unsigned int pageNumber;
+   unsigned int cacheSize;
    bool dirty;
-   unsigned int page;
    struct MemoryDevice* memoryDevice;
-   uint8_t storage[CACHED_STORAGE_PAGESIZE];
+   uint8_t storage[CACHED_STORAGE_PAGESIZE * 4];      // Times 4 to get 32bit width
-	uint8_t tempBuffer[CACHED_STORAGE_PAGESIZE];
+	uint8_t tempBuffer[CACHED_STORAGE_PAGESIZE * 4];   // Times 4 to get 32bit width
 };
 
 // -----------------------------------------------------------------------------
@@ -68,7 +68,7 @@ struct CachedStorage
 /**
 * Initializes the EEPROM hardware and reads the flash page
 */
-ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDevice* memoryDevice, unsigned int page, unsigned int pageSize);
+ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDevice* memoryDevice, unsigned int pageNumber);
 
 /**
 * Terminates the EEPROM hardware. SPI port is available again

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/MemoryDevice.h

@@ -38,11 +38,14 @@
 // Constant and macro definitions 
 // -----------------------------------------------------------------------------
 
-
+#define MEMORY_DEVICE_NEEDS_ERASE_BEFORE_WRITE     (true)
+#define MEMORY_DEVICE_NEEDS_NO_ERASE_BEFORE_WRITE  (false)
 
 // -----------------------------------------------------------------------------
 // Type definitions. 
 // -----------------------------------------------------------------------------
+
+
 struct MemoryDevice;
 
 typedef ErrorStatus (*MemoryReadFunction)(const struct MemoryDevice* self, uint32_t* buffer, uint32_t address, unsigned int length);
@@ -51,11 +54,14 @@ typedef ErrorStatus (*MemoryErasePageFunction)(const struct MemoryDevice* self,
 
 struct MemoryDevice
 {
+   bool initialized;
+   bool needsEraseBeforeWrite;
    MemoryReadFunction _read;
    MemoryWriteFunction _write;
    MemoryErasePageFunction _erasePage;
    uint32_t startAddress;
    uint32_t endAddress;
+   uint32_t pageSize;
 };
 
 // -----------------------------------------------------------------------------
@@ -74,7 +80,7 @@ struct MemoryDevice
  * @todo
  * -----------------------------------------------------------------------------
  */
-extern ErrorStatus MemoryDevice_construct(struct MemoryDevice* self, uint32_t startAddress, uint32_t endAddress, MemoryReadFunction read, MemoryWriteFunction write, MemoryErasePageFunction erasePage);
+extern ErrorStatus MemoryDevice_construct(struct MemoryDevice* self, uint32_t startAddress, uint32_t endAddress, uint32_t pageSize, bool needsEraseBeforeWrite, MemoryReadFunction read, MemoryWriteFunction write, MemoryErasePageFunction erasePage);
 
 
 /** ----------------------------------------------------------------------------

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/crc32.h

@@ -0,0 +1,113 @@
+// -----------------------------------------------------------------------------
+/// @file  crc32.h
+/// @brief File description
+// -----------------------------------------------------------------------------
+//  Micro-Key bv
+//  Industrieweg 28, 9804 TG Noordhorn
+//  Postbus 92, 9800 AB Zuidhorn
+//  The Netherlands
+//  Tel: +31 594 503020
+//  Fax: +31 594 505825
+//  Email: support@microkey.nl
+//  Web: www.microkey.nl
+// -----------------------------------------------------------------------------
+/// $Revision$
+/// $Author$
+/// $Date$
+//  (c) 2015 Micro-Key bv
+// -----------------------------------------------------------------------------
+
+/// @defgroup {group_name} {group_description}
+/// Description
+
+/// @file crc32.h
+/// @ingroup {group_name}
+
+#ifndef INC_CRC32_H_
+#define INC_CRC32_H_
+
+
+// -----------------------------------------------------------------------------
+// Include files 
+// -----------------------------------------------------------------------------
+
+#include <stdio.h>
+
+#include "stm32f10x.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions 
+// -----------------------------------------------------------------------------
+
+const static uint32_t crc32_tab[] = {
+   0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+   0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+   0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+   0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+   0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+   0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+   0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+   0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+   0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+   0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+   0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+   0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+   0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+   0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+   0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+   0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+   0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+   0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+   0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+   0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+   0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+   0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+   0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+   0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+   0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+   0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+   0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+   0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+   0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+   0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+   0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+   0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+   0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+   0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+   0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+   0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+   0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+   0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+   0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+   0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+   0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+   0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+   0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+// -----------------------------------------------------------------------------
+// Type definitions. 
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations 
+// -----------------------------------------------------------------------------
+
+
+/** ----------------------------------------------------------------------------
+ * crc32_calculate
+ * Description of function
+ *
+ * @param	crc
+ * @param	buffer
+ * @param   size
+ *
+ * @return	uint32_t
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern uint32_t crc32_calculate(uint32_t crc, const void* buffer, size_t size);
+#endif /* INC_CRC32_H_ */

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/CachedStorage.c

@@ -60,13 +60,22 @@
 // -----------------------------------------------------------------------------
 
 
-ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDevice* memoryDevice, unsigned int page, unsigned int pageSize)
+ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDevice* memoryDevice, unsigned int pageNumber)
 {
    ErrorStatus returnValue = SUCCESS;
    if (!self->initialized)
    {
-      self->page = page;
+      if (returnValue == SUCCESS)
-      self->dirty = false;
+      {
+         if (pageNumber > 0)
+         {
+            self->pageNumber     = pageNumber;
+         }
+         else
+         {
+            returnValue = ERROR;
+         }
+      }
 
       if (returnValue == SUCCESS)
       {
@@ -75,8 +84,12 @@ ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDev
       }
       if (returnValue == SUCCESS)
       {
-         MemoryDevice_read(self->memoryDevice, (uint32_t*)self->storage, (self->memoryDevice->startAddress + (self->page * self->pageSize)), self->pageSize);
+         self->cacheSize      = CACHED_STORAGE_PAGESIZE / 4;
-         self->initialized = true;
+         MemoryDevice_read(self->memoryDevice, (uint32_t*)self->storage, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
+         self->initialized    = true;
+         self->dirty          = false;
+
+         LOGGER_DEBUG(mainLog, "Created Cached Storage at page: %d", self->pageNumber);
       }
    }
    return returnValue;
@@ -196,6 +209,10 @@ uint8_t CachedStorage_readByte(struct CachedStorage* self, int offset)
          return 0;
       }
    }
+   else
+   {
+      return 0;
+   }
 }
 
 uint16_t CachedStorage_readHalfWord(struct CachedStorage* self, int offset)
@@ -211,6 +228,10 @@ uint16_t CachedStorage_readHalfWord(struct CachedStorage* self, int offset)
          return 0;
       }
    }
+   else
+   {
+      return 0;
+   }
 }
 
 uint32_t CachedStorage_readWord(struct CachedStorage* self, int offset)
@@ -226,6 +247,10 @@ uint32_t CachedStorage_readWord(struct CachedStorage* self, int offset)
          return 0;
       }
    }
+   else
+   {
+      return 0;
+   }
 }
 
 const void* CachedStorage_readBlob(struct CachedStorage* self, int offset)
@@ -241,6 +266,10 @@ const void* CachedStorage_readBlob(struct CachedStorage* self, int offset)
          return NULL;
       }
    }
+   else
+   {
+      return NULL;
+   }
 }
 
 void CachedStorage_commit(struct CachedStorage* self)
@@ -249,23 +278,27 @@ void CachedStorage_commit(struct CachedStorage* self)
    {
       if(self->dirty)
       {
-         MemoryDevice_read(self->memoryDevice, (uint32_t*)self->tempBuffer, (self->memoryDevice->startAddress + (self->page * self->pageSize)), self->pageSize);
+         MemoryDevice_read(self->memoryDevice, (uint32_t*)self->tempBuffer, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
 
 
-         if(memcmp(self->tempBuffer, self->storage, CACHED_STORAGE_PAGESIZE) != 0)
+         if(memcmp(self->tempBuffer, self->storage, (sizeof(self->storage) / sizeof(self->storage[0]))) != 0)
          {
-            MemoryDevice_write(self->memoryDevice, (uint32_t*)self->storage, (self->memoryDevice->startAddress + (self->page * 0x800)), 20);
+            if (self->memoryDevice->needsEraseBeforeWrite)
+            {
+               MemoryDevice_erasePage(self->memoryDevice, self->pageNumber);
+            }
+            MemoryDevice_write(self->memoryDevice, (uint32_t*)self->storage, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
          }
          else
          {
-            LOGGER_DEBUG(mainLog, "CachedStorage content on page %d unchanged, did not write", self->page);
+            LOGGER_DEBUG(mainLog, "CachedStorage content unchanged, did not write");
          }
 
          self->dirty = false;
       }
       else
       {
-         LOGGER_DEBUG(mainLog, "CachedStorage content on page %d unchanged, did not write", self->page);
+         LOGGER_DEBUG(mainLog, "CachedStorage content unchanged, did not write");
       }
    }
 }

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/MemoryDevice.c

@@ -56,15 +56,25 @@
 // Function definitions
 // -----------------------------------------------------------------------------
 
-ErrorStatus MemoryDevice_construct(struct MemoryDevice* self, uint32_t startAddress, uint32_t endAddress, MemoryReadFunction read, MemoryWriteFunction write, MemoryErasePageFunction erasePage)
+ErrorStatus MemoryDevice_construct(struct MemoryDevice* self, uint32_t startAddress, uint32_t endAddress, uint32_t pageSize, bool needsEraseBeforeWrite, MemoryReadFunction read, MemoryWriteFunction write, MemoryErasePageFunction erasePage)
 {
    ErrorStatus returnValue = SUCCESS;
 
-   self->_read          = read;
+   if (!self->initialized)
-   self->_write         = write;
+   {
-   self->_erasePage     = erasePage;
+      self->_read                   = read;
-   self->startAddress   = startAddress;
+      self->_write                  = write;
-   self->endAddress     = endAddress;
+      self->_erasePage              = erasePage;
+      self->startAddress            = startAddress;
+      self->endAddress              = endAddress;
+      self->pageSize                = pageSize;
+      self->initialized             = true;
+      self->needsEraseBeforeWrite   = needsEraseBeforeWrite;
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
 
    return returnValue;
 }

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/crc32.c

@@ -0,0 +1,68 @@
+// -----------------------------------------------------------------------------
+/// @file  crc32.c
+/// @brief Description
+// -----------------------------------------------------------------------------
+//  Micro-Key bv
+//  Industrieweg 28, 9804 TG Noordhorn
+//  Postbus 92, 9800 AB Zuidhorn
+//  The Netherlands
+//  Tel: +31 594 503020
+//  Fax: +31 594 505825
+//  Email: support@microkey.nl
+//  Web: www.microkey.nl
+// -----------------------------------------------------------------------------
+/// $Revision$
+/// $Author$
+/// $Date$
+//  (c) 2017 Micro-Key bv
+// -----------------------------------------------------------------------------
+
+/// @file crc32.c
+/// @ingroup {group_name}
+
+
+// -----------------------------------------------------------------------------
+// Include files
+// -----------------------------------------------------------------------------
+
+#include "crc32.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions
+// -----------------------------------------------------------------------------
+
+
+// -----------------------------------------------------------------------------
+// File-scope variables
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function definitions
+// -----------------------------------------------------------------------------
+
+uint32_t crc32_calculate(uint32_t crc, const void* buffer, size_t size)
+{
+   const uint8_t *p;
+
+   p = buffer;
+   crc = crc ^ ~0U;
+
+   while (size--)
+      crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
+
+   return crc ^ ~0U;
+}

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/InternalFlash.c

@@ -67,7 +67,12 @@ ErrorStatus InternalFlash_construct(struct InternalFlash* self)
    {
       if (returnValue == SUCCESS)
       {
-         returnValue = MemoryDevice_construct(&self->memoryDevice, INTERNAL_FLASH_BASE_ADDRESS, (INTERNAL_FLASH_BASE_ADDRESS + (INTERNAL_FLASH_NUMBER_OF_PAGES * INTERNAL_FLASH_PAGE_SIZE)), read, write, erasePage);
+         returnValue = MemoryDevice_construct(&self->memoryDevice,
+                                             INTERNAL_FLASH_BASE_ADDRESS,
+                                             INTERNAL_FLASH_BASE_ADDRESS + (INTERNAL_FLASH_NUMBER_OF_PAGES * INTERNAL_FLASH_PAGE_SIZE),
+                                             INTERNAL_FLASH_PAGE_SIZE,
+                                             MEMORY_DEVICE_NEEDS_ERASE_BEFORE_WRITE,
+                                             read, write, erasePage);
       }
       if (returnValue == SUCCESS)
       {
@@ -100,7 +105,7 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff
    ErrorStatus returnValue = SUCCESS;
    FLASH_Status FLASHStatus = FLASH_COMPLETE;
    uint32_t _address    = address;
-   uint32_t _endAddress = address + (length * 4);
+   uint32_t _endAddress = address + (length * 4) - 1;
    if (self->initialized)
    {
       if (returnValue == SUCCESS)
@@ -110,21 +115,26 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff
          {
             // Start address is NOT OK
             returnValue = ERROR;
+            LOGGER_DEBUG(mainLog, "StartAddress error %X (%X   %X)", _address, self->startAddress, self->endAddress);
          }
       }
       if (returnValue == SUCCESS)
       {
          // Verify end address boundaries
-         if ((_endAddress >= self->endAddress))
+         if ((_endAddress > self->endAddress))
          {
             // End address is NOT OK
             returnValue = ERROR;
+            LOGGER_DEBUG(mainLog, "EndAddress error %X (%X)", _endAddress, self->endAddress);
          }
       }
 
       // Boundaries OK - Write to FLASH
       if (returnValue == SUCCESS)
       {
+
+         LOGGER_DEBUG(mainLog, "Writing on address %X with length %d until address %X", _address, length *4, _endAddress);
+
          // Unlock the FLASH bank
          FLASH_Unlock();
 
@@ -132,11 +142,14 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff
          int bufferIndex = 0;
          while((_address < _endAddress) && (FLASHStatus == FLASH_COMPLETE))
          {
+           LOGGER_DEBUG(mainLog, "address %X --- Data %d", _address, buffer[bufferIndex]);
            FLASHStatus = FLASH_ProgramWord(_address, buffer[bufferIndex++]);
            // 32bit data register requires increment by 4 for next word address
            _address = _address + 4;
+           vTaskDelay(100);
          }
 
+         LOGGER_DEBUG(mainLog, "Writing done = flash status is %d", FLASHStatus);
          // After programming, lock the FLASH
          FLASH_Lock();
       }
@@ -156,6 +169,7 @@ ErrorStatus InternalFlash_read(const struct InternalFlash* self, uint32_t* buffe
 
    uint32_t _address    = address;
    uint32_t _endAddress = address + (length * 4);
+
    if (self->initialized)
    {
       if (returnValue == SUCCESS)
@@ -185,7 +199,7 @@ ErrorStatus InternalFlash_read(const struct InternalFlash* self, uint32_t* buffe
          while(_address < _endAddress)
          {
             buffer[bufferIndex++] = *(uint32_t*) _address;
-            // 32bit data register requires increment by 4 for next word address
+//            // 32bit data register requires increment by 4 for next word address
             _address = _address + 4;
          }
       }

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/STM32F10x_StdPeriph_Lib_V3.5.0/.settings/language.settings.xml

@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" console="false" env-hash="-24990244560702828" id="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="Ac6 SW4 STM32 MCU Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" console="false" env-hash="510461499985258339" id="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="Ac6 SW4 STM32 MCU Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>
@@ -16,7 +16,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" console="false" env-hash="-24990244560702828" id="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="Ac6 SW4 STM32 MCU Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" console="false" env-hash="510461499985258339" id="fr.ac6.mcu.ide.build.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="Ac6 SW4 STM32 MCU Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile

@@ -24,6 +24,8 @@ FreeRTOSFixes.o \
 hwValidationMenu.o \
 repairMenu.o \
 repairMenus.o \
+RepairPreset.o \
+RepairPresets.o \
 repairProcess.o \
 repairProcesses.o \
 repairProcessRow.o \

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/FreeRTOSConfig.h

@@ -44,7 +44,7 @@
 #define configTICK_RATE_HZ                ( ( TickType_t ) 1000 )
 #define configMAX_PRIORITIES              ( 5 )
 #define configMINIMAL_STACK_SIZE          ( ( unsigned short ) 256 )
-#define configTOTAL_HEAP_SIZE             ( ( size_t ) ( 0xA000 ) )
+#define configTOTAL_HEAP_SIZE             ( ( size_t ) ( 0x8000 ) )
 #define configMAX_TASK_NAME_LEN           ( 16 )
 #define configUSE_TRACE_FACILITY          1
 #define configUSE_16_BIT_TICKS            0

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/RepairPreset.h

@@ -31,6 +31,7 @@
 // Include files 
 // -----------------------------------------------------------------------------
 
+#include "stm32f10x.h"
 
 // -----------------------------------------------------------------------------
 // Constant and macro definitions 
@@ -60,5 +61,25 @@ struct RepairPreset
 // Function declarations 
 // -----------------------------------------------------------------------------
 
+/** ----------------------------------------------------------------------------
+ * RepairPreset_generateDefaultPreset
+ * Generates a default preset
+ * Values that are used are:
+ *    numberOfStages:     1
+ *    softstart:        100 seconds
+ *    Duration:         200 seconds
+ *    Voltage:            0 Volts
+ * The voltage is chosen to support both positive and negative voltages
+ *
+ * @param	self                       The repair preset object
+ * @param   presetNumber               the index of the preset
+ *
+ * @return	ErrorStatus                SUCCESS if generation was successful
+ *                                     ERROR otherwise
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern ErrorStatus RepairPreset_generateDefaultPreset(struct RepairPreset* self, unsigned int presetNumber);
 
 #endif /* REPAIRPRESET_H_ */

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/RepairPresets.h

@@ -0,0 +1,120 @@
+// -----------------------------------------------------------------------------
+/// @file  RepairPresets.h
+/// @brief File description
+// -----------------------------------------------------------------------------
+//  Micro-Key bv
+//  Industrieweg 28, 9804 TG Noordhorn
+//  Postbus 92, 9800 AB Zuidhorn
+//  The Netherlands
+//  Tel: +31 594 503020
+//  Fax: +31 594 505825
+//  Email: support@microkey.nl
+//  Web: www.microkey.nl
+// -----------------------------------------------------------------------------
+/// $Revision$
+/// $Author$
+/// $Date$
+//  (c) 2015 Micro-Key bv
+// -----------------------------------------------------------------------------
+
+/// @defgroup {group_name} {group_description}
+/// Description
+
+/// @file RepairPresets.h
+/// @ingroup {group_name}
+
+#ifndef REPAIRPRESETS_H_
+#define REPAIRPRESETS_H_
+
+
+// -----------------------------------------------------------------------------
+// Include files 
+// -----------------------------------------------------------------------------
+
+#include "stm32f10x.h"
+
+#include "RepairPreset.h"
+
+#include "CachedStorage.h"
+// -----------------------------------------------------------------------------
+// Constant and macro definitions 
+// -----------------------------------------------------------------------------
+
+#define REPAIR_PRESETS_NUMBER_OF_PRESETS  (9)
+
+// -----------------------------------------------------------------------------
+// Type definitions. 
+// -----------------------------------------------------------------------------
+
+typedef enum
+{
+   REPAIR_PRESETS_ANODE,
+   REPAIR_PRESETS_CATHODE,
+   REPAIR_PRESETS_MCP,
+   REPAIR_PRESETS_TESLA,
+}REPAIR_PRESETS_ID;
+
+// -----------------------------------------------------------------------------
+// Function declarations 
+// -----------------------------------------------------------------------------
+
+
+/** ----------------------------------------------------------------------------
+ * RepairPresets_construct
+ * Constructor for repair presets
+ *
+ * @return	ErrorStatus
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern ErrorStatus RepairPresets_construct(struct CachedStorage* presetStorage, struct MemoryDevice* memoryDevice);
+
+
+/** ----------------------------------------------------------------------------
+ * RepairPresets_destruct
+ * Destructor for repair presets
+ *
+ * @return	void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void RepairPresets_destruct(void);
+
+
+/** ----------------------------------------------------------------------------
+ * RepairPresets_loadPresets
+ * Loads a new set of presets into the cached storage
+ * Prior to loading, any previously loaded presets will be unloaded
+ * automatically
+ *
+ * @param	presetID                   Identifier of the set of presets
+ *
+ * @return	ErrorStatus                SUCCESS if loading was successful
+ *                                     ERROR otherwise
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern ErrorStatus RepairPresets_loadPresets(REPAIR_PRESETS_ID presetID);
+
+
+/** ----------------------------------------------------------------------------
+ * RepairPresets_getPreset
+ * Returns a pointer to a specific repair preset
+ *
+ * @param	index                      Index of the repair preset to return
+ *                                     must be between 1 and
+ *                                     REPAIR_PRESETS_NUMBER_OF_PRESETS
+ *
+ * @return	const struct RepairPreset*
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern const struct RepairPreset* RepairPresets_getPreset(unsigned int index);
+
+
+
+#endif /* REPAIRPRESETS_H_ */

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h

@@ -35,7 +35,7 @@
 
 #include "stm32f10x.h"
 
-#include "repairPreset.h"
+#include "RepairPreset.h"
 
 // -----------------------------------------------------------------------------
 // Constant and macro definitions 

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/hsb-mrts.h

@@ -33,7 +33,11 @@
 
 #include "stm32f10x.h"
 
+#include "RepairPreset.h"
+#include "RepairPresets.h"
+
 #include "gpio.h"
+#include "InternalFlash.h"
 
 // -----------------------------------------------------------------------------
 // Constant and macro definitions 
@@ -67,6 +71,32 @@
 #define HSB_DAC_TESLA_MAX_VOLTAGE      (6200)
 
 
+// FLASH ADDRESSES FOR DATA STORAGE
+
+// Define storage for presets, which is the biggest storage part
+// Each set of presets is written/saved on a dedicated page. This reduces
+// cache size when erasing page prior to write
+#define APP_FLASH_PRESET_ANODE_PAGE       (122)
+#define APP_FLASH_PRESET_CATHODE_PAGE     (123)
+#define APP_FLASH_PRESET_MCP_PAGE         (124)
+#define APP_FLASH_PRESET_TESLA_PAGE       (125)
+#define APP_FLASH_STORAGE_PRESET_SIZE     (sizeof(struct RepairPreset) * REPAIR_PRESETS_NUMBER_OF_PRESETS)
+#define APP_FLASH_STORAGE_PRESET_ANODE    (INTERNAL_FLASH_BASE_ADDRESS + INTERNAL_FLASH_PAGE_SIZE * APP_FLASH_PRESET_ANODE_PAGE)
+#define APP_FLASH_STORAGE_PRESET_CATHODE  (INTERNAL_FLASH_BASE_ADDRESS + INTERNAL_FLASH_PAGE_SIZE * APP_FLASH_PRESET_CATHODE_PAGE)
+#define APP_FLASH_STORAGE_PRESET_MCP      (INTERNAL_FLASH_BASE_ADDRESS + INTERNAL_FLASH_PAGE_SIZE * APP_FLASH_PRESET_MCP_PAGE)
+#define APP_FLASH_STORAGE_PRESET_TESLA    (INTERNAL_FLASH_BASE_ADDRESS + INTERNAL_FLASH_PAGE_SIZE * APP_FLASH_PRESET_TESLA_PAGE)
+
+// Define storage for device parameters like PID constants and others
+#define APP_FLASH_PARAMETERS_PAGE         (126)
+#define APP_FLASH_STORAGE_PARAMETERS      (INTERNAL_FLASH_BASE_ADDRESS + INTERNAL_FLASH_PAGE_SIZE * APP_FLASH_PARAMETERS_PAGE)
+
+// Define storage for power-down detection flag
+#define APP_FLASH_POWERDOWN_PAGE          (127)
+#define APP_FLASH_STORAGE_POWERDOWN       (INTERNAL_FLASH_BASE_ADDRESS + INTERNAL_FLASH_PAGE_SIZE * APP_FLASH_POWERDOWN_PAGE)
+
+
+
+
 // Exports of objects on application level
 extern struct Display* const mainDisplay;
 // -----------------------------------------------------------------------------

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h

@@ -38,9 +38,10 @@
 #include "semphr.h"
 
 #include "stm32f10x.h"
-#include "repairPreset.h"
+#include "RepairPreset.h"
 #include "repairProcess.h"
 
+#include "CachedStorage.h"
 #include "Interlock.h"
 #include "keypadMatrix.h"
 #include "Observable.h"
@@ -134,6 +135,8 @@ struct RepairMenu
    bool initialized;
    struct Display* display;
    struct KeyboardDevice* keyboardDevice;
+   struct MemoryDevice* memoryDevice;
+   struct CachedStorage presetStorage;
    T_MenuState menuState;
    int cursorIndex;
    int scrollOffset;
@@ -167,7 +170,7 @@ struct RepairMenu
  * @todo
  * -----------------------------------------------------------------------------
  */
-extern ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* display, struct KeyboardDevice* keyboardDevice, int taskPriority, uint16_t stackSize, Observer repairScreenUpdateObserver);
+extern ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* display, struct KeyboardDevice* keyboardDevice, struct MemoryDevice* memoryDevice, int taskPriority, uint16_t stackSize, Observer repairScreenUpdateObserver);
 
 
 /** ----------------------------------------------------------------------------

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairProcess.h

@@ -40,7 +40,7 @@
 
 #include "ADConverter.h"
 #include "DAConverter.h"
-#include "repairPreset.h"
+#include "RepairPreset.h"
 #include "repairProcessRow.h"
 #include "SignalProfileGenerator.h"
 

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairProcesses.h

@@ -33,7 +33,7 @@
 
 #include "stm32f10x.h"
 
-#include "repairPreset.h"
+#include "RepairPreset.h"
 #include "repairProcess.h"
 
 // -----------------------------------------------------------------------------

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/linker/LinkerScript.ld

@@ -59,10 +59,12 @@ _Min_Heap_Size = 0;      /* required amount of heap  */
 _Min_Stack_Size = 0x400; /* required amount of stack */
 
 /* Memories definition */
+/*Remove 6 pages (12k) for data storage from FLASH */
 MEMORY
 {
+
   RAM (xrw)		: ORIGIN = 0x20000000, LENGTH = 64K
-  ROM (rx)		: ORIGIN = 0x8000000, LENGTH = 254K
+  ROM (rx)		: ORIGIN = 0x8000000, LENGTH = 244K	
 }
 
 /* Sections */

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Error.c

@@ -70,7 +70,7 @@ ErrorStatus Error_construct(void)
    Observable_construct(&observable);
 
    errorQueue = xQueueCreate(ERROR_QUEUE_SIZE, sizeof(struct ErrorQueueItem));
-   xTaskCreate(ErrorTask, "ErrorTask", 1024, NULL, 1, &errorTaskHandle);
+   xTaskCreate(ErrorTask, "ErrorTask", 512, NULL, 1, &errorTaskHandle);
 
    return SUCCESS;
 }

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPreset.c

@@ -0,0 +1,69 @@
+// -----------------------------------------------------------------------------
+/// @file  RepairPreset.c
+/// @brief File description
+// -----------------------------------------------------------------------------
+//  Micro-Key bv
+//  Industrieweg 28, 9804 TG Noordhorn
+//  Postbus 92, 9800 AB Zuidhorn
+//  The Netherlands
+//  Tel: +31 594 503020
+//  Fax: +31 594 505825
+//  Email: support@microkey.nl
+//  Web: www.microkey.nl
+// -----------------------------------------------------------------------------
+/// $Revision$
+/// $Author$
+/// $Date$
+//  (c) 2015 Micro-Key bv
+// -----------------------------------------------------------------------------
+
+/// @defgroup {group_name} {group_description}
+/// Description
+
+/// @file RepairPreset.c
+/// @ingroup {group_name}
+
+#ifndef REPAIRPRESET_C_
+#define REPAIRPRESET_C_
+
+
+// -----------------------------------------------------------------------------
+// Include files 
+// -----------------------------------------------------------------------------
+
+#include "RepairPreset.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions 
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions. 
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations 
+// -----------------------------------------------------------------------------
+
+ErrorStatus RepairPreset_generateDefaultPreset(struct RepairPreset* self, unsigned int presetNumber)
+{
+   ErrorStatus returnValue = SUCCESS;
+
+   self->presetNumber                  = presetNumber;
+   self->numberOfStages                = 1;
+   self->preset[0].softstartDuration   = 100;
+   self->preset[0].duration            = 200;
+   self->preset[0].voltage             = 0;
+   // Generate dummy presets to fill the memory
+   self->preset[1].softstartDuration   = 0;
+   self->preset[1].duration            = 0;
+   self->preset[1].voltage             = 0;
+
+   return returnValue;
+}
+
+#endif /* REPAIRPRESET_C_ */

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPresets.c

@@ -0,0 +1,320 @@
+// -----------------------------------------------------------------------------
+/// @file  RepairPresets.c
+/// @brief Description
+// -----------------------------------------------------------------------------
+//  Micro-Key bv
+//  Industrieweg 28, 9804 TG Noordhorn
+//  Postbus 92, 9800 AB Zuidhorn
+//  The Netherlands
+//  Tel: +31 594 503020
+//  Fax: +31 594 505825
+//  Email: support@microkey.nl
+//  Web: www.microkey.nl
+// -----------------------------------------------------------------------------
+/// $Revision$
+/// $Author$
+/// $Date$
+//  (c) 2017 Micro-Key bv
+// -----------------------------------------------------------------------------
+
+/// @file RepairPresets.c
+/// @ingroup {group_name}
+
+
+// -----------------------------------------------------------------------------
+// Include files
+// -----------------------------------------------------------------------------
+
+#include <stdbool.h>
+
+#include "hsb-mrts.h"
+#include "RepairPresets.h"
+
+#include "CachedStorage.h"
+#include "crc32.h"
+#include "MemoryDevice.h"
+
+#include "Logger.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions
+// -----------------------------------------------------------------------------
+
+struct RepairPresets
+{
+   bool initialized;
+   bool presetsLoaded;
+   REPAIR_PRESETS_ID currentPresetID;
+   struct CachedStorage* presetStorage;
+   struct MemoryDevice* memoryDevice;
+};
+
+struct RepairPresetStorageClass
+{
+   uint32_t crc;
+   struct RepairPreset preset;
+};
+
+// -----------------------------------------------------------------------------
+// File-scope variables
+// -----------------------------------------------------------------------------
+
+static struct RepairPresets _self      = {.initialized = false, .presetsLoaded = false};
+struct RepairPresets* const self       = &_self;
+
+// -----------------------------------------------------------------------------
+// Function declarations
+// -----------------------------------------------------------------------------
+
+static ErrorStatus RepairPresets_verifyCRCs(void);
+static ErrorStatus RepairPresets_verifyPresetCRC(struct RepairPresetStorageClass* repairPreset);
+static ErrorStatus RepairPresets_writePreset(struct RepairPreset* preset);
+
+// -----------------------------------------------------------------------------
+// Function definitions
+// -----------------------------------------------------------------------------
+
+
+ErrorStatus RepairPresets_construct(struct CachedStorage* presetStorage, struct MemoryDevice* memoryDevice)
+{
+   ErrorStatus returnValue = SUCCESS;
+   if (!self->initialized)
+   {
+      if (returnValue == SUCCESS)
+      {
+         if (presetStorage != NULL)
+         {
+            self->presetStorage = presetStorage;
+         }
+         else
+         {
+            returnValue = ERROR;
+         }
+      }
+
+      if (returnValue == SUCCESS)
+      {
+         if (memoryDevice != NULL)
+         {
+            if (memoryDevice->initialized)
+            {
+               self->memoryDevice = memoryDevice;
+            }
+            else
+            {
+               returnValue = ERROR;
+            }
+         }
+         else
+         {
+            returnValue = ERROR;
+         }
+      }
+      self->initialized = true;
+      self->presetsLoaded = false;
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+   return returnValue;
+}
+
+
+void RepairPresets_destruct(void)
+{
+   if (self->initialized)
+   {
+      self->initialized = false;
+      self->presetsLoaded = false;
+   }
+}
+
+
+
+ErrorStatus RepairPresets_loadPresets(REPAIR_PRESETS_ID presetID)
+{
+   ErrorStatus returnValue = SUCCESS;
+
+   if (self->initialized)
+   {
+      // Destruct the cachedStorage to remove all previous data
+      CachedStorage_destruct(self->presetStorage);
+
+      // Get the new preset ID
+      self->currentPresetID = presetID;
+      // Construct new cached Storage with base address defined by the preset ID
+      unsigned int pageNumber;
+      switch (self->currentPresetID)
+      {
+         case REPAIR_PRESETS_ANODE:
+         {
+            pageNumber = APP_FLASH_PRESET_ANODE_PAGE;
+            break;
+         }
+         case REPAIR_PRESETS_CATHODE:
+         {
+            pageNumber = APP_FLASH_PRESET_CATHODE_PAGE;
+            break;
+         }
+         case REPAIR_PRESETS_MCP:
+         {
+            pageNumber = APP_FLASH_PRESET_MCP_PAGE;
+            break;
+         }
+         case REPAIR_PRESETS_TESLA:
+         {
+            pageNumber = APP_FLASH_PRESET_TESLA_PAGE;
+            break;
+         }
+         default:
+         {
+            LOGGER_ERROR(mainLog, "Unknown preset ID");
+            returnValue = ERROR;
+         }
+      }
+
+      // If Preset ID was valid, go on loading presets from memory
+      if (returnValue == SUCCESS)
+      {
+         // Create new cachedStorage with preset page number
+         returnValue = CachedStorage_construct(self->presetStorage, self->memoryDevice, pageNumber);
+      }
+      else
+      {
+         self->presetsLoaded = false;
+      }
+
+      // Check the CRC on the loaded presets
+      if (returnValue == SUCCESS)
+      {
+         returnValue = RepairPresets_verifyCRCs();
+      }
+
+      // CRCs are verified
+      // If CRCs are correct on all presets, returnValue will still be SUCCESS
+      if (returnValue == SUCCESS)
+      {
+         self->presetsLoaded = true;
+      }
+      // If any CRC is wrong
+
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+
+   return returnValue;
+}
+
+
+const struct RepairPreset* RepairPresets_getPreset(unsigned int index)
+{
+   const struct RepairPreset* returnValue = NULL;
+   if (self->initialized)
+   {
+      if (self->presetsLoaded)
+      {
+         // Index is human-readable, thus starting with 1
+         if ((index > 0) || (index <= REPAIR_PRESETS_NUMBER_OF_PRESETS))
+         {
+            struct RepairPresetStorageClass* tempPreset;
+            tempPreset = CachedStorage_readBlob(self->presetStorage, (index - 1) * sizeof(struct RepairPresetStorageClass));
+            returnValue = (const struct RepairPreset*)&tempPreset->preset;
+         }
+      }
+   }
+   return returnValue;
+}
+
+
+static ErrorStatus RepairPresets_verifyCRCs(void)
+{
+   ErrorStatus returnValue = SUCCESS;
+   if (self->initialized)
+   {
+      int loopCounter;
+      struct RepairPresetStorageClass _tempPresetStorage;
+      struct RepairPresetStorageClass* tempPresetStorage = &_tempPresetStorage;
+      for (loopCounter = 0; loopCounter < REPAIR_PRESETS_NUMBER_OF_PRESETS; loopCounter++)
+      {
+         // Load next preset from cache
+         tempPresetStorage = CachedStorage_readBlob(self->presetStorage, loopCounter * sizeof(struct RepairPresetStorageClass));
+         // Verify CRC
+         returnValue = RepairPresets_verifyPresetCRC(tempPresetStorage);
+         // Check CRC verification
+         if (returnValue != SUCCESS)
+         {
+            // CRC was not correct - replace corrupted preset with a DEFAULT preset
+            RepairPreset_generateDefaultPreset(&tempPresetStorage->preset, loopCounter + 1);
+            LOGGER_DEBUG(mainLog, "PRESET %d: Softstart: %d, Duration: %d, Voltage: %d", tempPresetStorage->preset.presetNumber, tempPresetStorage->preset.preset[0].softstartDuration, tempPresetStorage->preset.preset[0].duration, tempPresetStorage->preset.preset[0].voltage);
+            // Write default preset to Cache
+            RepairPresets_writePreset(&tempPresetStorage->preset);
+         }
+      }
+      // Commit cache to memory - will not write if no changes have been made
+      CachedStorage_commit(self->presetStorage);
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+   return returnValue;
+}
+
+
+static ErrorStatus RepairPresets_verifyPresetCRC(struct RepairPresetStorageClass* repairPreset)
+{
+   ErrorStatus returnValue = SUCCESS;
+   if (self->initialized)
+   {
+      // Calculate the CRC of the given repair preset
+      uint32_t tempCRC;
+      tempCRC = crc32_calculate(0, &repairPreset->preset, sizeof(struct RepairPreset));
+      // Compare loaded and calculated CRC values - must be equal
+      if (repairPreset->crc != tempCRC)
+      {
+         // CRCs do not match
+         returnValue = ERROR;
+         LOGGER_ERROR(mainLog, "CRC ERROR at repair preset %d (calculated %X but loaded %X)", repairPreset->preset.presetNumber, (unsigned int)tempCRC, (unsigned int)repairPreset->crc);
+      }
+      else
+      {
+         LOGGER_INFO(mainLog, "CRC OK at repair preset %d (calculated %X and loaded %X)", repairPreset->preset.presetNumber, (unsigned int)tempCRC, (unsigned int)repairPreset->crc);
+      }
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+   return returnValue;
+}
+
+
+
+static ErrorStatus RepairPresets_writePreset(struct RepairPreset* preset)
+{
+   ErrorStatus returnValue = SUCCESS;
+   if (self->initialized)
+   {
+      struct RepairPresetStorageClass tempPresetStorage;
+      tempPresetStorage.preset = *preset;
+      // Calculate CRC over preset
+      tempPresetStorage.crc = crc32_calculate(0, &tempPresetStorage.preset, sizeof(struct RepairPreset));
+      // Put default preset on Cache
+      CachedStorage_writeBlob(self->presetStorage, (tempPresetStorage.preset.presetNumber - 1) * sizeof(struct RepairPresetStorageClass), &tempPresetStorage, sizeof(struct RepairPresetStorageClass));
+
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+   return returnValue;
+}

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/hsb-mrts.c

@@ -177,6 +177,7 @@ ErrorStatus hsb_disableSafety(void)
       vTaskDelay(100);
    }
 
+
    Interlock_setEXTI(interlock, DISABLE);
 
    return returnValue;

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c

@@ -203,15 +203,18 @@ static void initTask(void* parameters)
    xTaskCreate(ledBlinkTask, (const char* const)"ledTask", 100, &ledTaskArguments, 0, &ledTaskHandle);
 
    // Construct the displays
-//   Displays_construct();
+   Displays_construct();
 
    // Construct the AD Converters
-//   ADConverters_construct();
+   ADConverters_construct();
 
    // Construct the DA Converters
-//   DAConverters_construct();
+   DAConverters_construct();
 
-//   hsb_generateStartScreen(mainDisplay);
+   // Construct the repair presets
+   RepairPresets_construct(&cs, &iFlash->memoryDevice);
+
+   hsb_generateStartScreen(mainDisplay);
    // Let start screen stay for 5 seconds
 //   vTaskDelay(INIT_START_SCREEN_DELAY);
 
@@ -236,38 +239,11 @@ static void initTask(void* parameters)
 //   HwValidationMenu_construct(hwValidation, &uart1->device, &hwTestItems, 1, 1024);
 
    // Construct the repair menu
-//   repairMenus_construct();
+   repairMenus_construct();
 
 
-   uint32_t buffer[128];
-   int i;
-   for (i = 0; i < 128; i++)
-   {
-      buffer[i] = i + 4;
-      vTaskDelay(20);
-   }
-//
-//   vTaskDelay(5000);
-//
-   CachedStorage_construct(&cs, &iFlash->memoryDevice, 127, CACHED_STORAGE_PAGESIZE);
-
-   MemoryDevice_erasePage(&iFlash->memoryDevice, 127);
-
-   CachedStorage_writeBlob(&cs, 0, buffer, sizeof(buffer));
-   CachedStorage_commit(&cs);
-////
-//   vTaskDelay(1000);
-//
-   const uint32_t* buffer2;
-   buffer2 = CachedStorage_readBlob(&cs, 0);
-   for (i = 0; i < 128; i++)
-   {
-      LOGGER_DEBUG(mainLog, "Value %d ---> %d", i, (unsigned int)buffer2[i]);
-      vTaskDelay(20);
-   }
-
    // Create task that repeats to print out TASK information on the logger
-   xTaskCreate(printSystemInfoTask, (const char* const)"SysInfoTask", 512, NULL, 0, &sysTaskHandle);
+//   xTaskCreate(printSystemInfoTask, (const char* const)"SysInfoTask", 512, NULL, 0, &sysTaskHandle);
 
    // Delete this init task
    vTaskDelete(NULL);

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c

@@ -28,6 +28,7 @@
 #include "stdio.h"
 #include "string.h"
 #include "repairMenu.h"
+#include "RepairPreset.h"
 #include "repairProcess.h"
 #include "repairProcesses.h"
 
@@ -72,38 +73,6 @@
 static const char cursorValue[2] = {0x7E, '\0'};
 
 
-// TEMPORARY PRESET STORAGE
-static const struct RepairPreset preset1t = {.presetNumber = 1, .numberOfStages = 1, .preset[0].softstartDuration = 100, .preset[0].duration =  200, .preset[0].voltage = 1000};
-static const struct RepairPreset preset2t = {.presetNumber = 2, .numberOfStages = 1, .preset[0].softstartDuration = 200, .preset[0].duration =  400, .preset[0].voltage = 3000};
-static const struct RepairPreset preset3t = {.presetNumber = 3, .numberOfStages = 1, .preset[0].softstartDuration = 300, .preset[0].duration =  600, .preset[0].voltage = 300};
-static const struct RepairPreset preset4t = {.presetNumber = 4, .numberOfStages = 1, .preset[0].softstartDuration = 400, .preset[0].duration =  800, .preset[0].voltage = 400};
-static const struct RepairPreset preset5t = {.presetNumber = 5, .numberOfStages = 1, .preset[0].softstartDuration = 500, .preset[0].duration = 1000, .preset[0].voltage = 500};
-static const struct RepairPreset preset6t = {.presetNumber = 6, .numberOfStages = 1, .preset[0].softstartDuration = 120, .preset[0].duration = 240, .preset[0].voltage = 800};
-static const struct RepairPreset preset7t = {.presetNumber = 7, .numberOfStages = 1, .preset[0].softstartDuration = 700, .preset[0].duration = 1400, .preset[0].voltage = 700};
-static const struct RepairPreset preset8t = {.presetNumber = 8, .numberOfStages = 1, .preset[0].softstartDuration = 120, .preset[0].duration = 300, .preset[0].voltage = 4000};
-static const struct RepairPreset preset9t = {.presetNumber = 9, .numberOfStages = 2, .preset[0].softstartDuration = 900, .preset[0].duration = 1800, .preset[0].voltage = 4000, .preset[1].softstartDuration = 100, .preset[1].duration = 1800, .preset[1].voltage = 5000};
-
-static const struct RepairPreset preset1a = {.presetNumber = 1, .numberOfStages = 1, .preset[0].softstartDuration = 000, .preset[0].duration =  200, .preset[0].voltage = 1000};
-static const struct RepairPreset preset2a = {.presetNumber = 2, .numberOfStages = 1, .preset[0].softstartDuration = 200, .preset[0].duration =  400, .preset[0].voltage = 3000};
-static const struct RepairPreset preset3a = {.presetNumber = 3, .numberOfStages = 1, .preset[0].softstartDuration = 300, .preset[0].duration =  600, .preset[0].voltage = 300};
-static const struct RepairPreset preset4a = {.presetNumber = 4, .numberOfStages = 1, .preset[0].softstartDuration = 400, .preset[0].duration =  800, .preset[0].voltage = 400};
-static const struct RepairPreset preset5a = {.presetNumber = 5, .numberOfStages = 1, .preset[0].softstartDuration = 500, .preset[0].duration = 1000, .preset[0].voltage = 500};
-static const struct RepairPreset preset6a = {.presetNumber = 6, .numberOfStages = 1, .preset[0].softstartDuration = 600, .preset[0].duration = 1200, .preset[0].voltage = 8000};
-static const struct RepairPreset preset7a = {.presetNumber = 7, .numberOfStages = 1, .preset[0].softstartDuration = 200, .preset[0].duration = 600, .preset[0].voltage = 10000};
-static const struct RepairPreset preset8a = {.presetNumber = 8, .numberOfStages = 1, .preset[0].softstartDuration = 120, .preset[0].duration = 300, .preset[0].voltage = 6000};
-static const struct RepairPreset preset9a = {.presetNumber = 9, .numberOfStages = 2, .preset[0].softstartDuration = 900, .preset[0].duration = 1800, .preset[0].voltage = 6000, .preset[1].softstartDuration = 100, .preset[1].duration = 1800, .preset[1].voltage = 8000};
-
-static const struct RepairPreset preset1n = {.presetNumber = 1, .numberOfStages = 1, .preset[0].softstartDuration = 100, .preset[0].duration =  200, .preset[0].voltage = -1000};
-static const struct RepairPreset preset2n = {.presetNumber = 2, .numberOfStages = 1, .preset[0].softstartDuration = 200, .preset[0].duration =  400, .preset[0].voltage = -1800};
-static const struct RepairPreset preset3n = {.presetNumber = 3, .numberOfStages = 1, .preset[0].softstartDuration = 300, .preset[0].duration =  600, .preset[0].voltage = -300};
-static const struct RepairPreset preset4n = {.presetNumber = 4, .numberOfStages = 1, .preset[0].softstartDuration = 400, .preset[0].duration =  800, .preset[0].voltage = -400};
-static const struct RepairPreset preset5n = {.presetNumber = 5, .numberOfStages = 1, .preset[0].softstartDuration = 500, .preset[0].duration = 1000, .preset[0].voltage = -500};
-static const struct RepairPreset preset6n = {.presetNumber = 6, .numberOfStages = 1, .preset[0].softstartDuration = 600, .preset[0].duration = 1200, .preset[0].voltage = -600};
-static const struct RepairPreset preset7n = {.presetNumber = 7, .numberOfStages = 1, .preset[0].softstartDuration = 700, .preset[0].duration = 1400, .preset[0].voltage = -700};
-static const struct RepairPreset preset8n = {.presetNumber = 8, .numberOfStages = 1, .preset[0].softstartDuration = 120, .preset[0].duration = 300, .preset[0].voltage = -1800};
-static const struct RepairPreset preset9n = {.presetNumber = 9, .numberOfStages = 2, .preset[0].softstartDuration = 900, .preset[0].duration = 1800, .preset[0].voltage = -1200, .preset[1].softstartDuration = 100, .preset[1].duration = 1800, .preset[1].voltage = -1600};
-static const struct RepairPreset* presetArray[9];
-
 // -----------------------------------------------------------------------------
 // Function declarations
 // -----------------------------------------------------------------------------
@@ -152,7 +121,7 @@ static ErrorStatus repairMenu_addKeyAction_SCROLLDOWN (struct MenuPage* self, ch
 // -----------------------------------------------------------------------------
 
 
-ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* display, struct KeyboardDevice* keyboardDevice, int taskPriority, uint16_t stackSize, Observer repairScreenUpdateObserver)
+ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* display, struct KeyboardDevice* keyboardDevice, struct MemoryDevice* memoryDevice, int taskPriority, uint16_t stackSize, Observer repairScreenUpdateObserver)
 {
    ErrorStatus returnValue = SUCCESS;
 
@@ -182,43 +151,35 @@ ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* displa
          }
       }
 
+      if (returnValue == SUCCESS)
+      {
+         if (memoryDevice->initialized)
+         {
+            self->memoryDevice = memoryDevice;
+            self->presetStorage.initialized = false;
+         }
+         else
+         {
+            returnValue = ERROR;
+         }
+      }
+
       if (returnValue == SUCCESS)
       {
          if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
          {
-            presetArray[0] = &preset1n;
+            // Loading of presets is done when selecting either Cathode or MCP repair
-            presetArray[1] = &preset2n;
+
-            presetArray[2] = &preset3n;
-            presetArray[3] = &preset4n;
-            presetArray[4] = &preset5n;
-            presetArray[5] = &preset6n;
-            presetArray[6] = &preset7n;
-            presetArray[7] = &preset8n;
-            presetArray[8] = &preset9n;
          }
          else if (PCBA_getInstance()->pcba == PCBA_Anode)
          {
-            presetArray[0] = &preset1a;
+            RepairPresets_loadPresets(REPAIR_PRESETS_ANODE);
-            presetArray[1] = &preset2a;
+            self->repairPreset = RepairPresets_getPreset(1);
-            presetArray[2] = &preset3a;
-            presetArray[3] = &preset4a;
-            presetArray[4] = &preset5a;
-            presetArray[5] = &preset6a;
-            presetArray[6] = &preset7a;
-            presetArray[7] = &preset8a;
-            presetArray[8] = &preset9a;
          }
          else if (PCBA_getInstance()->pcba == PCBA_Tesla)
          {
-            presetArray[0] = &preset1t;
+            RepairPresets_loadPresets(REPAIR_PRESETS_TESLA);
-            presetArray[1] = &preset2t;
+            self->repairPreset = RepairPresets_getPreset(1);
-            presetArray[2] = &preset3t;
-            presetArray[3] = &preset4t;
-            presetArray[4] = &preset5t;
-            presetArray[5] = &preset6t;
-            presetArray[6] = &preset7t;
-            presetArray[7] = &preset8t;
-            presetArray[8] = &preset9t;
          }
 
          // Construct the menu based on PCBA information
@@ -239,7 +200,6 @@ ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* displa
             vSemaphoreCreateBinary(self->repairScreenUpdateSemaphore);
             self->observer = repairScreenUpdateObserver;
             self->initialized = true;
-            self->repairPreset = presetArray[0];
             self->cursorIndex = 1;
             self->scrollOffset = 0;
             LOGGER_INFO(mainLog, "Repair Menu task started");
@@ -490,6 +450,7 @@ static void repairMenu_printPreset(struct RepairMenu* self)
 {
    int loopCounter;
    char buffer[self->display->displayDevice->parameters.numberOfColumns];
+   // Print the preset information of the current preset under the cursor, NOT the preset that is currently selected
    snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->cursorIndex);
    // Always print Row1 (index0), ignoring the scrolling index
    Display_write(self->display, buffer, 1, 1);
@@ -501,15 +462,15 @@ static void repairMenu_printPreset(struct RepairMenu* self)
    snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Volt:");
    Display_write(self->display, buffer, 4, 1);
 
-   for (loopCounter = 0; loopCounter < presetArray[self->cursorIndex - 1]->numberOfStages; loopCounter++)
+   for (loopCounter = 0; loopCounter < RepairPresets_getPreset(self->cursorIndex)->numberOfStages; loopCounter++)
    {
-      snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (presetArray[self->cursorIndex - 1]->preset[loopCounter].softstartDuration / 60));
+      snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->cursorIndex)->preset[loopCounter].softstartDuration / 60));
       Display_write(self->display, buffer, 2, 8 + loopCounter * 7);
 
-      snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (presetArray[self->cursorIndex - 1]->preset[loopCounter].duration / 60));
+      snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->cursorIndex)->preset[loopCounter].duration / 60));
       Display_write(self->display, buffer, 3, 8 + loopCounter * 7);
 
-      snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", presetArray[self->cursorIndex - 1]->preset[loopCounter].voltage);
+      snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->cursorIndex)->preset[loopCounter].voltage);
       Display_write(self->display, buffer, 4, 8 + loopCounter * 7);
    }
 
@@ -694,26 +655,29 @@ static void repairMenu_scrollDownIndexHandler(struct RepairMenu* self)
 
 static void repairMenu_selectCathodeRepair(struct RepairMenu* self, int cursorIndex)
 {
+   RepairPresets_loadPresets(REPAIR_PRESETS_CATHODE);
+   self->repairPreset = RepairPresets_getPreset(1);
    CathodeMCP_switchToCathode();
 }
 
 
 static void repairMenu_selectMCPRepair(struct RepairMenu* self, int cursorIndex)
 {
+   RepairPresets_loadPresets(REPAIR_PRESETS_MCP);
+   self->repairPreset = RepairPresets_getPreset(1);
    CathodeMCP_switchToMCP();
 }
 
 
 static void repairMenu_selectPreset(struct RepairMenu* self, int cursorIndex)
 {
-   self->repairPreset = presetArray[cursorIndex - 1];
+   self->repairPreset = RepairPresets_getPreset(cursorIndex);
    LOGGER_INFO(mainLog, "Preset %d selected", cursorIndex);
 
    Display_clearScreen(self->display);
    char buffer[20];
-   snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d", cursorIndex);
+   snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", cursorIndex);
-   Display_write(self->display, buffer, 2, 7);
+   Display_write(self->display, buffer, 2, 2);
-   Display_write(self->display, "Selected", 3, 6);
    vTaskDelay(2000);
 }
 
@@ -919,10 +883,8 @@ static ErrorStatus repairMenu_createMenu(struct RepairMenu* self)
    repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[PRESETMENU], 'R', PRESSED, RM_PRESET_PRINT);
 
    repairMenu_createMenuPage(&self->menuArray[RM_PRESET_PRINT], MENU_HAS_NO_CURSOR, 10);
-   repairMenu_addKeyAction_SCROLLUP(&self->menuArray[RM_PRESET_PRINT], 'U', PRESSED);
-   repairMenu_addKeyAction_SCROLLDOWN(&self->menuArray[RM_PRESET_PRINT], 'D', PRESSED);
    repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[RM_PRESET_PRINT], 'X', PRESSED, PRESETMENU);
-   repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[PRESETMENU], 'L', PRESSED, PRESETMENU);
+   repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[RM_PRESET_PRINT], 'L', PRESSED, PRESETMENU);
 
    repairMenu_createMenuPage(&self->menuArray[REPAIR_RUNNING], MENU_HAS_NO_CURSOR, 4);
    repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIR_RUNNING], 'X', PRESSED, REPAIR_ASK_PAUSE);

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c

@@ -76,7 +76,7 @@ ErrorStatus repairMenus_construct(void)
    if (returnValue == SUCCESS)
    {
       // Create first repair menu
-      returnValue = repairMenu_construct(mainMenu, mainDisplay, &storm700->keyboardDevice, HSB_MAINMENU_TASK_PRIORITY, HSB_MAINMENU_TASK_STACKSIZE, repairMenu_freeMainMenuRepairScreenUpdateSemaphore);
+      returnValue = repairMenu_construct(mainMenu, mainDisplay, &storm700->keyboardDevice, &iFlash->memoryDevice, HSB_MAINMENU_TASK_PRIORITY, HSB_MAINMENU_TASK_STACKSIZE, repairMenu_freeMainMenuRepairScreenUpdateSemaphore);
    }
 
    if (returnValue == SUCCESS)

S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c

@@ -34,7 +34,6 @@
 
 #include "hsb-mrts.h"
 #include "repairProcess.h"
-#include "repairPreset.h"
 
 #include "internalADC.h"
 #include "Logger.h"