Fixed multiple bugs and errors.

- Added WARNING handler
- put voltage calculations to dedicated module

fixed last errors. Updated menu repair screen without ERROR from PID 

This is version 0.9.0.3, which is used for the first duration test
Will also be tagged

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

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

@@ -11,7 +11,7 @@ ROOTDIR = ../
 
 LIBRARY_NAME = libHAL.a
 
-CCFLAGS = -c -O2 -Wall -g -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) $(ADDITIONAL_SWITCHES) \
+CCFLAGS = -c -O2 -Wall -Werror -g -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) $(ADDITIONAL_SWITCHES) \
 -Iinc \
 -I$(ROOTDIR)/Platform/inc \
 -I$(ROOTDIR)/hsb-mrts/inc \

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

@@ -49,11 +49,13 @@
 struct DACDevice;
 
 typedef ErrorStatus (*DACWriteFunction)(const struct DACDevice* self, uint32_t voltage);
+typedef uint32_t (*DACReadbackFunction)(const struct DACDevice* self);
 
 
 struct DACDevice
 {
    DACWriteFunction _write;
+   DACReadbackFunction _readback;
    bool initialized;
    unsigned int resolutionInBits;
 };
@@ -76,7 +78,7 @@ struct DACDevice
  * @todo
  * -----------------------------------------------------------------------------
  */
-extern ErrorStatus DACDevice_construct(struct DACDevice* self, DACWriteFunction write, unsigned int resolutionInBits);
+extern ErrorStatus DACDevice_construct(struct DACDevice* self, DACWriteFunction write, DACReadbackFunction readback, unsigned int resolutionInBits);
 
 
 /** ----------------------------------------------------------------------------
@@ -106,4 +108,7 @@ extern void DACDevice_destruct(struct DACDevice* self);
  */
 extern ErrorStatus DACDevice_write(const struct DACDevice* self, uint32_t voltage);
 
+
+extern uint32_t DACDevice_getCurrentValue(const struct DACDevice* self);
+
 #endif /* INC_DACDEVICE_H_ */

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

@@ -238,6 +238,6 @@ extern ErrorStatus MAX5715Channel_construct(struct MAX5715_DAC* self, struct MAX
  * @todo
  * -----------------------------------------------------------------------------
  */
-extern ErrorStatus MAX5715Channel_setValue(const struct MAX5715_DAC* self, uint16_t value);
+extern ErrorStatus MAX5715Channel_setValue(struct MAX5715_DAC* self, uint16_t value);
 
 #endif /* INC_MAX5715_H_ */

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

@@ -39,51 +39,6 @@
 // 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. 

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

@@ -25,13 +25,13 @@
 // Include files
 // -----------------------------------------------------------------------------
 
-#include "Logger.h"
 #include <string.h>
+
 #include "CachedStorage.h"
+#include "Logger.h"
 
 #include "InternalFlash.h"
 
-#include "stm32f10x_flash.h"
 
 // -----------------------------------------------------------------------------
 // Constant and macro definitions
@@ -92,10 +92,6 @@ ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDev
             returnValue = ERROR;
             LOGGER_ERROR(mainLog, "Failed to malloc to tempbuffer");
          }
-         else
-         {
-            LOGGER_INFO(mainLog, "Created tempBuffer memory with size %x at address %p", self->cacheSize, self->tempBuffer);
-         }
       }
 
       if (returnValue == SUCCESS)
@@ -106,10 +102,6 @@ ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDev
             returnValue = ERROR;
             LOGGER_ERROR(mainLog, "Failed to malloc to storage");
          }
-         else
-         {
-            LOGGER_INFO(mainLog, "Created storage memory with size %x at address %p", self->cacheSize, self->storage);
-         }
       }
 
       if (returnValue == SUCCESS)
@@ -118,7 +110,7 @@ ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDev
          self->initialized    = true;
          self->dirty          = false;
 
-         LOGGER_DEBUG(mainLog, "Created Cached Storage at page: %d", self->pageNumber);
+         LOGGER_INFO(mainLog, "Created Cached Storage at page: %d", self->pageNumber);
       }
    }
    return returnValue;
@@ -130,7 +122,6 @@ void CachedStorage_destruct(struct CachedStorage* self)
    {
       vPortFree(self->storage);
       vPortFree(self->tempBuffer);
-      LOGGER_INFO(mainLog, "Free'd buffers");
       self->initialized = false;
    }
 }
@@ -159,7 +150,7 @@ void CachedStorage_writeBlob(struct CachedStorage* self, int offset, const void*
       }
       else
       {
-         LOGGER_ERROR(mainLog, "WriteBlob failed at offset %d, blobsize %d --- %p", offset, blobSize, self->storage[offset]);
+         LOGGER_ERROR(mainLog, "WriteBlob failed at offset %d, blobsize %d --- %p", offset, blobSize, &self->storage[offset]);
       }
    }
 }
@@ -195,7 +186,7 @@ const void* CachedStorage_readBlob(struct CachedStorage* self, int offset)
       }
       else
       {
-         LOGGER_ERROR(mainLog, "ReadBlob failed at offset %d --- %p", offset, self->storage[offset]);
+         LOGGER_ERROR(mainLog, "ReadBlob failed at offset %d --- %p", offset, &self->storage[offset]);
          return NULL;
       }
    }
@@ -224,14 +215,14 @@ void CachedStorage_commit(struct CachedStorage* self)
          }
          else
          {
-            LOGGER_DEBUG(mainLog, "CachedStorage content unchanged, did not write");
+            LOGGER_INFO(mainLog, "No changes made to cache");
          }
 
          self->dirty = false;
       }
       else
       {
-         LOGGER_DEBUG(mainLog, "CachedStorage content unchanged, did not write");
+         LOGGER_INFO(mainLog, "No changes made to cache");
       }
    }
 }

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

@@ -57,21 +57,15 @@
 // Function definitions
 // -----------------------------------------------------------------------------
 
-ErrorStatus DACDevice_construct(struct DACDevice* self, DACWriteFunction write, unsigned int resolutionInBits)
+ErrorStatus DACDevice_construct(struct DACDevice* self, DACWriteFunction write, DACReadbackFunction readback, unsigned int resolutionInBits)
 {
    ErrorStatus returnValue = SUCCESS;
    if (!self->initialized)
    {
-      if (write != NULL)
-      {
       self->_write            = write;
+      self->_readback         = readback;
       self->resolutionInBits  = resolutionInBits;
       self->initialized       = true;
-      }
-      else
-      {
-         returnValue = ERROR;
-      }
    }
    else
    {
@@ -111,3 +105,26 @@ ErrorStatus DACDevice_write(const struct DACDevice* self, uint32_t voltage)
    }
    return returnValue;
 }
+
+
+
+uint32_t DACDevice_getCurrentValue(const struct DACDevice* self)
+{
+   uint32_t returnValue = SUCCESS;
+   if (self->initialized)
+   {
+      if (self->_readback != NULL)
+      {
+         returnValue = self->_readback(self);
+      }
+      else
+      {
+         returnValue = 0;
+      }
+   }
+   else
+   {
+      returnValue = 0;
+   }
+   return returnValue;
+}

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

@@ -271,7 +271,7 @@ static void loggerTask(void* parameters)
 				}
 			#endif
 			
-			uint32_t seconds = RTC_GetCounter();
+			unsigned int seconds = (unsigned int)RTC_GetCounter();
 
 			#if defined(ENABLE_SERIAL_LOGGING)
 				// Formatted print

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

@@ -53,6 +53,7 @@
 // -----------------------------------------------------------------------------
 
 static ErrorStatus channelWrite(const struct DACDevice* self, uint32_t voltage);
+static uint32_t channelReadback (const struct DACDevice* self);
 
 // -----------------------------------------------------------------------------
 // Function definitions
@@ -166,7 +167,7 @@ ErrorStatus MAX5715Channel_construct(struct MAX5715_DAC* self, struct MAX5715* p
 
             if (returnValue == SUCCESS)
             {
-               returnValue = DACDevice_construct(&self->dacDevice, channelWrite, MAX5715_RESOLUTION_IN_BITS);
+               returnValue = DACDevice_construct(&self->dacDevice, channelWrite, channelReadback, MAX5715_RESOLUTION_IN_BITS);
             }
          }
          else
@@ -187,7 +188,7 @@ ErrorStatus MAX5715Channel_construct(struct MAX5715_DAC* self, struct MAX5715* p
 }
 
 
-ErrorStatus MAX5715Channel_setValue(const struct MAX5715_DAC* self, uint16_t value)
+ErrorStatus MAX5715Channel_setValue(struct MAX5715_DAC* self, uint16_t value)
 {
    ErrorStatus returnValue = SUCCESS;
 
@@ -195,8 +196,11 @@ ErrorStatus MAX5715Channel_setValue(const struct MAX5715_DAC* self, uint16_t val
    {
       if ((self->initialized) && (self->parent->initialized))
       {
+         ///TODO value must be verified with DAC device boarders (add limits to class)
+
+         self->value = value;
          // Send data to CODEn register
-         MAX5715_writeCODEn(self->parent, self->id, value);
+         MAX5715_writeCODEn(self->parent, self->id, self->value);
 
          // Load CODEn register to DAC output
          MAX5715_writeLOADn(self->parent, self->id);
@@ -225,3 +229,11 @@ static ErrorStatus channelWrite(const struct DACDevice* self, uint32_t voltage)
    // MASK the uint32_t DAC value (voltage) with the resolution of the MAX5715 DAC
    return MAX5715Channel_setValue((struct MAX5715_DAC*)self, (((1 << MAX5715_RESOLUTION_IN_BITS) - 1) & voltage));
 }
+
+
+static uint32_t channelReadback (const struct DACDevice* self)
+{
+   struct MAX5715_DAC* tempDac = (struct MAX5715_DAC*)self;
+
+   return tempDac->value;
+}

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

@@ -38,10 +38,56 @@
 // -----------------------------------------------------------------------------
 
 
+
 // -----------------------------------------------------------------------------
 // File-scope variables
 // -----------------------------------------------------------------------------
 
+const static uint32_t crc32_tab[] = {
+   0x00000001, 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
+};
 
 
 // -----------------------------------------------------------------------------

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

@@ -1,9 +1,9 @@
 # Define release version for firmware here
 RELEASE_PRODUCT = \""S0\""
 RELEASE_MAJOR = 0
-RELEASE_MINOR = 2
+RELEASE_MINOR = 9
 RELEASE_BRANCH = 0
-RELEASE_PATCH = 0
+RELEASE_PATCH = 3
 
 PLATFORM_OLIMEX_STM32_H107 = OLI_STM32_H107
 

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

@@ -11,7 +11,7 @@ ROOTDIR = ../
 
 LIBRARY_NAME = libPlatform.a
 
-CCFLAGS = -c -O2 -Wall -g -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) \
+CCFLAGS = -c -O2 -Wall -Werror -g -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) \
 -Iinc \
 -I$(ROOTDIR)/HAL/inc \
 -I$(ROOTDIR)/hsb-mrts/inc \

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

@@ -126,6 +126,7 @@ ErrorStatus Keypad_construct(struct Keypad* self, size_t numberOfRows, size_t nu
          LOGGER_INFO(mainLog, "Keypad task started");
          self->initialized = true;
 
+//         // TUBE REPAIR
 //         struct KeypadQueueItem rxQueueItem;
 //         rxQueueItem.rowCoordinate     = 0;
 //         rxQueueItem.columnCoordinate  = 0;
@@ -137,7 +138,8 @@ ErrorStatus Keypad_construct(struct Keypad* self, size_t numberOfRows, size_t nu
 //         rxQueueItem.keyEvent          = RELEASED;
 //         // Put event in queue
 //         xQueueSend(self->rxQueue, &rxQueueItem, 0);
-////
+//
+//         // SELECT CATHODE
 //         rxQueueItem.rowCoordinate     = 0;
 //         rxQueueItem.columnCoordinate  = 0;
 //         rxQueueItem.keyEvent          = PRESSED;
@@ -149,6 +151,7 @@ ErrorStatus Keypad_construct(struct Keypad* self, size_t numberOfRows, size_t nu
 //         // Put event in queue
 //         xQueueSend(self->rxQueue, &rxQueueItem, 0);
 //
+//         // SELECT PRESET
 //         rxQueueItem.rowCoordinate     = 0;
 //         rxQueueItem.columnCoordinate  = 0;
 //         rxQueueItem.keyEvent          = PRESSED;
@@ -160,17 +163,19 @@ ErrorStatus Keypad_construct(struct Keypad* self, size_t numberOfRows, size_t nu
 //         // Put event in queue
 //         xQueueSend(self->rxQueue, &rxQueueItem, 0);
 //
-//         rxQueueItem.rowCoordinate     = 1;
+//         // SELECT PRESET 7
-//         rxQueueItem.columnCoordinate  = 2;
+//         rxQueueItem.rowCoordinate     = 2;
+//         rxQueueItem.columnCoordinate  = 0;
 //         rxQueueItem.keyEvent          = PRESSED;
 //         // Put event in queue
 //         xQueueSend(self->rxQueue, &rxQueueItem, 0);
-//         rxQueueItem.rowCoordinate     = 1;
+//         rxQueueItem.rowCoordinate     = 2;
-//         rxQueueItem.columnCoordinate  = 2;
+//         rxQueueItem.columnCoordinate  = 0;
 //         rxQueueItem.keyEvent          = RELEASED;
 //         // Put event in queue
 //         xQueueSend(self->rxQueue, &rxQueueItem, 0);
 //
+//         // START
 //         rxQueueItem.rowCoordinate     = 0;
 //         rxQueueItem.columnCoordinate  = 1;
 //         rxQueueItem.keyEvent          = PRESSED;

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

@@ -16,6 +16,7 @@ ADConverter.o \
 ADConverters.o \
 DAConverter.o \
 DAConverters.o \
+DeviceParameters.o \
 Display.o \
 Displays.o \
 DisplayContent.o \
@@ -24,6 +25,8 @@ FreeRTOSFixes.o \
 hwValidationMenu.o \
 MenuCore.o \
 MenuElements.o \
+PIDParameters.o \
+PIN.o \
 repairMenu.o \
 repairMenus.o \
 RepairPreset.o \
@@ -32,6 +35,8 @@ repairProcess.o \
 repairProcesses.o \
 repairProcessRow.o \
 SignalProfileGenerator.o \
+Voltage.o \
+Warning.o \
 \
 heap_4.o\
 list.o \
@@ -71,7 +76,7 @@ OLI_STM32_H107: export OBJ_DIR := obj_release/
 OLI_STM32_H107: export OBJECTS := $(OBJECTS_GEN)
 OLI_STM32_H107: export OBJECTS_MAIN := $(OBJECTS_MAIN)
 OLI_STM32_H107: export CROSS_COMPILE := arm-none-eabi-
-OLI_STM32_H107: export CCFLAGS := -c -O2 -Wall -g -lc -lm -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) $(INCLUDES) 
+OLI_STM32_H107: export CCFLAGS := -c -O2 -Wall -Werror -g -lc -lm -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) $(INCLUDES) 
 OLI_STM32_H107: export ASFLAGS := -g -mapcs-32
 OLI_STM32_H107: export LDFLAGS := -g -nostartfiles -mcpu=cortex-m3 -mthumb -T$(LINKER_SCRIPTS_DIR)/$(LINKER_SCRIPT) -Wl,-Map=hsb_mrts_OLI_STM32_H107.map
 OLI_STM32_H107: export LDARCHIVES := -L. -L$(STM32_STDPERIPH_ROOT) -L$(PLATFORM_DIR) -L$(HAL_DIR) -lhsb_mrts_OLI_STM32_H107 -lPlatform -lHAL -lSTM_StdPeriph

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

@@ -99,4 +99,7 @@ extern void ADConverter_destruct(struct ADConverter* self);
  */
 extern int ADConverter_getInputVoltage(const struct ADConverter* self);
 
+
+extern unsigned int ADConverter_getInputConverterValue(const struct ADConverter* self);
+
 #endif /* ADCONVERTER_H_ */

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

@@ -102,4 +102,18 @@ extern void DAConverter_destruct(struct DAConverter* self);
 extern ErrorStatus DAConverter_setOutputVoltage(const struct DAConverter* self, int voltage);
 
 
+/** ----------------------------------------------------------------------------
+ * DAConverter_getCurrentValue
+ * Description of function
+ *
+ * @param	self
+ * @param
+ * @return	uint32_t
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern uint32_t DAConverter_getCurrentValue(const struct DAConverter* self);
+
+
 #endif /* DACONVERTER_H_ */

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

@@ -108,4 +108,19 @@ extern struct PIDParameters* DeviceParameters_getPIDParameters(void);
  */
 extern struct PIN* DeviceParameters_getPIN(void);
 
+
+/** ----------------------------------------------------------------------------
+ * DeviceParameters_saveParameters
+ * Description of function
+ *
+ * @return	void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void DeviceParameters_saveParameters(void);
+
+ErrorStatus DeviceParameters_writePIDParameters(struct PIDParameters* parameters);
+ErrorStatus DeviceParameters_writePIN(struct PIN* pin);
+
 #endif /* DEVICEPARAMETERS_H_ */

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

@@ -52,6 +52,9 @@ typedef enum
    INTERLOCK_COMMON_FAIL,
    POWERENABLE_FAIL,
    REPAIR_FAIL,
+   ERROR_CRC_PIN,
+   ERROR_CRC_PARAMETERS,
+   ERROR_CRC_PRESETS
 } T_ErrorCode;
 
 // -----------------------------------------------------------------------------

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

@@ -100,8 +100,8 @@ struct MenuCore
    struct MenuPage menuArray[RM_NUMBER_OF_MENUS];
    struct Display* display;
    struct KeyboardDevice* keyboardDevice;
-   char errorMessage[MENUCORE_DISPLAY_ROW_LENGTH];
+   char errorMessage[MENUCORE_DISPLAY_ROW_LENGTH + 1];
-   char warningMessage[MENUCORE_DISPLAY_ROW_LENGTH];
+   char warningMessage[MENUCORE_DISPLAY_ROW_LENGTH + 1];
    TaskHandle_t taskHandle;
    int TaskPriority;
    bool runTask;
@@ -109,6 +109,7 @@ struct MenuCore
    int cursorIndex;
    int selectionIndex;
    int scrollOffset;
+   char insertString[MENUCORE_DISPLAY_ROW_LENGTH + 1];
    int insertValue;
    uint32_t popUpCounter;
    MenuCoreFunctionCall _handleStateFunction;

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

@@ -71,8 +71,10 @@ typedef enum
    // ADMINISTRATION MENUs
    // --------------------------------------------------------------------------
    RM_ADMIN_CATHODEMCP_SELECT,
+   RM_ADMINMENU_PIN_VERIFICATION,
    RM_ADMINMENU,
-   RM_ADMIN_CHANGEPIN,
+   RM_ADMIN_CHANGEPIN_FIRST_INSERT,
+   RM_ADMIN_CHANGEPIN_SECOND_INSERT,
    RM_ADMIN_IOCONTROL,
    RM_ADMIN_PRESET_CONFIG_SELECT,
    RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART,
@@ -81,18 +83,25 @@ typedef enum
    RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART,
    RM_ADMIN_PRESET_CONFIG_SECOND_DURATION,
    RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE,
+   RM_ADMIN_PID_CONFIG_KP,
+   RM_ADMIN_PID_CONFIG_KI,
+   RM_ADMIN_PID_CONFIG_KD,
    RM_ADMIN_INFO,
 
    RM_ADMIN_IO_INTERLOCK,
    RM_ADMIN_IO_SOLENOID,
    RM_ADMIN_IO_VOLTAGE_IN,
-   RM_ADMIN_IO_VOLTAGE_OUT,
+   RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1,
+   RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2,
+   RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3,
+   RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP,
    RM_ADMIN_IO_TESLAGUN,
 
 
    // --------------------------------------------------------------------------
    // CALIBRATION MENUs
    // --------------------------------------------------------------------------
+   RM_CALIBRATIONMENU_PIN_VERIFICATION,
    RM_CALIBRATIONMENU,
 
    RM_ERROR_STATE,

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

@@ -126,7 +126,8 @@ static const char MenuText_ADMINMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_
                   "  1.Change Pin",
                   "  2.I/O control",
                   "  3.Preset config",
-                  "  4.Info & Version",
+                  "  4.PID constants",
+                  "  5.Info & Version",
          },
          {
                   //FRENCH TBW
@@ -188,22 +189,6 @@ static const char MenuText_ADMINSOLENOIDMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUC
 };
 
 
-// Administration Get Voltage input screen
-static const char MenuText_ADMINVOLTAGINMAINMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] =
-{
-         {
-                  "Get voltage in",
-                  "  1.Channel 1",
-                  "  2.Channel 2",
-                  "  3.Channel 3",
-
-         },
-         {
-                  //FRENCH TBW
-         }
-};
-
-
 // Administration Get Voltage output screen
 static const char MenuText_ADMINVOLTAGOUTMAINMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] =
 {

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

@@ -38,7 +38,11 @@
 
 struct PIDParameters
 {
-
+   int Kp;                             // proportional constant
+   int Ki;                             // integration constant
+   int Kd;                             // differential constant
+   int iMin;
+   int iMax;
 };
 
 // -----------------------------------------------------------------------------
@@ -51,5 +55,86 @@ struct PIDParameters
 // Function declarations 
 // -----------------------------------------------------------------------------
 
+/** ----------------------------------------------------------------------------
+ * PIDParameters_generateDefaultParameters
+ * Description of function
+ *
+ * @param	self
+ * @param
+ * @return	void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIDParameters_generateDefaultParameters(struct PIDParameters* self);
 
+
+/** ----------------------------------------------------------------------------
+ * PIDParameters_setKp
+ * Description of function
+ *
+ * @param	self
+ * @param	Kp
+ * @return	void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIDParameters_setKp(struct PIDParameters* self, int Kp);
+
+
+/** ----------------------------------------------------------------------------
+ * PIDParameters_setKi
+ * Description of function
+ *
+ * @param   self
+ * @param   Ki
+ * @return  void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIDParameters_setKi(struct PIDParameters* self, int Ki);
+
+
+/** ----------------------------------------------------------------------------
+ * PIDParameters_setKd
+ * Description of function
+ *
+ * @param   self
+ * @param   Kd
+ * @return  void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIDParameters_setKd(struct PIDParameters* self, int Kd);
+
+
+/** ----------------------------------------------------------------------------
+ * PIDParameters_setiMin
+ * Description of function
+ *
+ * @param   self
+ * @param   Kp
+ * @return  void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIDParameters_setiMin(struct PIDParameters* self, int iMin);
+
+
+/** ----------------------------------------------------------------------------
+ * PIDParameters_setiMax
+ * Description of function
+ *
+ * @param   self
+ * @param   Kp
+ * @return  void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIDParameters_setiMax(struct PIDParameters* self, int iMax);
 #endif /* PIDPARAMETERS_H_ */

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

@@ -31,25 +31,93 @@
 // Include files 
 // -----------------------------------------------------------------------------
 
+#include <stdbool.h>
+
+#include "stm32f10x.h"
 
 // -----------------------------------------------------------------------------
 // Constant and macro definitions 
 // -----------------------------------------------------------------------------
 
+#define PIN_NUMBER_OF_DIGITS           (4)
+
+// -----------------------------------------------------------------------------
+// Type definitions.
+// -----------------------------------------------------------------------------
+
 struct PIN
 {
+   char firstDigit;
+   char secondDigit;
+   char thirdDigit;
+   char fourthDigit;
 
+   char pinchangeFirstInsert[5];
+   char pinchangeSecondInsert[5];
 };
 
-// -----------------------------------------------------------------------------
-// Type definitions. 
-// -----------------------------------------------------------------------------
-
-
-
 // -----------------------------------------------------------------------------
 // Function declarations 
 // -----------------------------------------------------------------------------
 
 
+/** ----------------------------------------------------------------------------
+ * PIN_generateDefaultPIN
+ * Description of function
+ *
+ * @param	self
+ * @param
+ * @return	void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIN_generateDefaultPIN(struct PIN* self);
+
+
+/** ----------------------------------------------------------------------------
+ * PIN_isOK
+ * Description of function
+ *
+ * @param	self
+ * @param	PinToVerify
+ * @return	bool
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern bool PIN_isOK(struct PIN* self, char* const pin);
+
+
+/** ----------------------------------------------------------------------------
+ * PIN_changePinFirstInsert
+ * Transmits the first PIN insertion in order to change the current PIN
+ *
+ * @param	self
+ * @param	firstPinInsert
+ * @return	void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void PIN_changePinFirstInsert(struct PIN* self, char* const firstPinInsert);
+
+
+/** ----------------------------------------------------------------------------
+ * PIN_changePinSecondInsert
+ * transmits the second PIN insertion in order to change the current PIN.
+ * Only accepts second insert after first insert has been called. Afterwards,
+ * both inserts a compared. If equal, the new PIN is registered. Otherwise an
+ * error message is generated
+ *
+ * @param   self
+ * @param   firstPinInsert
+ * @return  ErrorStatus                SUCCESS if both PIN inserts are equal
+ *                                     ERROR otherwise
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern ErrorStatus PIN_changePinSecondInsert(struct PIN* self, char* const secondPinInsert);
+
 #endif /* PIN_H_ */

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

@@ -70,6 +70,8 @@ struct SignalProfileGenerator
    uint32_t startTime;
    uint32_t softStartTimer;
    uint32_t voltageHoldTimer;
+   uint32_t totalStartTime;
+   uint32_t totalRunTime;
 
    int pauseStartVoltage;
    uint32_t pauseStartTime;
@@ -103,8 +105,14 @@ extern void SignalProfileGenerator_pause(struct SignalProfileGenerator* self);
 extern bool SignalProfileGenerator_isPaused(struct SignalProfileGenerator* self);
 
 
+extern bool SignalProfileGenerator_isFinished(struct SignalProfileGenerator* self);
+
+
 extern void SignalProfileGenerator_continue(struct SignalProfileGenerator* self);
 
 
 extern uint32_t SignalProfileGenerator_getRemainingTime(const struct SignalProfileGenerator* self);
+
+
+extern uint32_t SignalProfileGenerator_getTotalRepairTime(const struct SignalProfileGenerator* self);
 #endif /* INC_SIGNALPROFILEGENERATOR_H_ */

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

@@ -0,0 +1,58 @@
+// -----------------------------------------------------------------------------
+/// @file  Voltage.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 Voltage.h
+/// @ingroup {group_name}
+
+#ifndef VOLTAGE_H_
+#define VOLTAGE_H_
+
+
+// -----------------------------------------------------------------------------
+// Include files 
+// -----------------------------------------------------------------------------
+
+#include "stm32f10x.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions 
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions. 
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations 
+// -----------------------------------------------------------------------------
+
+extern int Voltage_calculateVoltage(uint32_t value, uint32_t resolutionInBits, int minVoltage, int maxVoltage);
+
+
+extern uint32_t Voltage_calculateDeviceValue(int value, uint32_t resolutionInBits, int minVoltage, int maxVoltage);
+
+
+#endif /* VOLTAGE_H_ */

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

@@ -31,22 +31,81 @@
 // Include files 
 // -----------------------------------------------------------------------------
 
+#include "stm32f10x.h"
 
+#include "Observable.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
 // -----------------------------------------------------------------------------
 // Constant and macro definitions 
 // -----------------------------------------------------------------------------
 
 
-
 // -----------------------------------------------------------------------------
 // Type definitions. 
 // -----------------------------------------------------------------------------
 
-
+typedef enum
+{
+   WARNING_INTERLOCK_COMMON_FAIL,
+} T_WarningCode;
 
 // -----------------------------------------------------------------------------
 // Function declarations 
 // -----------------------------------------------------------------------------
 
 
+/** ----------------------------------------------------------------------------
+ * Warning_construct
+ * Constructs the Warning handler
+ *
+ * @return  ErrorStatus                SUCCESS if construction was successful
+ *                                     ERROR otherwise
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern ErrorStatus Warning_construct(void);
+
+
+/** ----------------------------------------------------------------------------
+ * Warning_getObservable
+ * Returns the observable of the Warning handler
+ *
+ * @return  struct Observable*         Observable of the Warning handler
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern struct Observable* Warning_getObservable(void);
+
+
+/** ----------------------------------------------------------------------------
+ * Warning_postWarning
+ * Posts a new Warning
+ *
+ * @param   warningCode                  Warning CODE
+ *
+ * @return  void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void Warning_postWarning(T_WarningCode warningCode);
+
+
+/** ----------------------------------------------------------------------------
+ * Warning_postWarningFromISR
+ * Posts a new Warning from an ISR context
+ *
+ * @param   warningCode                  Warning CODE
+ *
+ * @return  void
+ *
+ * @todo
+ * -----------------------------------------------------------------------------
+ */
+extern void Warning_postWarningFromISR(T_WarningCode warningCode);
+
 #endif /* WARNING_H_ */

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

@@ -123,8 +123,10 @@ extern struct Display* const mainDisplay;
  */
 extern ErrorStatus hsb_generateStartScreen(struct Display* Display);
 
+extern ErrorStatus hsb_enableSafetyWithError(void);
 
+extern ErrorStatus hsb_enableSafetyWithWarning(void);
 
-extern ErrorStatus hsb_enableSafety(void);
 extern ErrorStatus hsb_disableSafety(void);
+extern bool hsb_safetyIsEnabled(void);
 #endif /* HSB_MRTS_H_ */

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

@@ -38,6 +38,8 @@
 #include "semphr.h"
 
 #include "stm32f10x.h"
+
+#include "Error.h"
 #include "MenuCore.h"
 #include "RepairPreset.h"
 #include "repairProcess.h"
@@ -142,6 +144,9 @@ extern void repairMenu_feedSecondsCounter(struct RepairMenu* self);
 extern void repairMenu_feedSecondsCounterFromISR(struct RepairMenu* self);
 
 
+extern void repairMenu_interlockWarning(struct RepairMenu* self, T_INTERLOCK_ID interlockID);
+
+
 /** ----------------------------------------------------------------------------
  * repairMenu_interlockFailed
  * Interlock verification failed
@@ -161,6 +166,9 @@ extern void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID i
 extern void repairMenu_processFailed(struct RepairMenu* self);
 
 
+extern void repairMenu_printCRCFailure(struct RepairMenu* self, T_ErrorCode errorCode);
+
+
 extern void repairMenu_menuStateHandle(struct MenuCore* menuCore);
 
 

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

@@ -175,6 +175,9 @@ extern bool repairProcess_isProcessRunning(struct RepairProcess* self);
 extern uint32_t repairProcess_getRemainingRepairTime(const struct RepairProcess* self);
 
 
+extern uint32_t repairProcess_getTotalRepairtime(const struct RepairProcess* self);
+
+
 /** ----------------------------------------------------------------------------
  * repairProcess_getRowInformation
  * Returns the current active repair time in seconds.

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

@@ -26,6 +26,7 @@
 // -----------------------------------------------------------------------------
 
 #include "ADConverter.h"
+#include "Voltage.h"
 
 #include "Logger.h"
 
@@ -50,7 +51,7 @@
 // Function declarations
 // -----------------------------------------------------------------------------
 
-static int calculateVoltage(const struct ADConverter* self, uint32_t adcValue);
+
 
 // -----------------------------------------------------------------------------
 // Function definitions
@@ -90,53 +91,20 @@ int ADConverter_getInputVoltage(const struct ADConverter* self)
       uint32_t adcValue;
       adcValue = ADCDevice_read(self->adcDevice);
 
-      returnValue = calculateVoltage(self, adcValue);
+      returnValue = Voltage_calculateVoltage(adcValue, self->adcDevice->resolutionInBits, self->minVoltage, self->maxVoltage);
    }
-
    return returnValue;
 }
 
 
-static int calculateVoltage(const struct ADConverter* self, uint32_t adcValue)
+unsigned int ADConverter_getInputConverterValue(const struct ADConverter* self)
 {
-   int returnValue = 0;
+   unsigned int returnValue = 0;
+
    if (self->initialized)
    {
-      int maxAdcValue = ((1 << self->adcDevice->resolutionInBits) - 1);
+      returnValue = ADCDevice_read(self->adcDevice);
-
-      returnValue = (int)adcValue * (self->maxVoltage - self->minVoltage);
-      returnValue = returnValue / maxAdcValue;
-      returnValue = returnValue + self->minVoltage;
-
-      // Differ between an positive and negative scale
-      if (self->maxVoltage > self->minVoltage)
-      {
-         // Common scale with a higher maximum value than the minimum value
-         if (returnValue < self->minVoltage)
-         {
-            returnValue = self->minVoltage;
-         }
-         else if (returnValue > self->maxVoltage)
-         {
-            returnValue = self->maxVoltage;
-         }
-      }
-      else
-      {
-         // Negative scale where the ADC value (positive) must be translated in a negative voltage
-         if (returnValue > self->minVoltage)
-         {
-            returnValue = self->minVoltage;
-         }
-         else if (returnValue < self->maxVoltage)
-         {
-            returnValue = self->maxVoltage;
-         }
-      }
-   }
-   else
-   {
-      returnValue = 0;
    }
    return returnValue;
 }
+

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

@@ -25,9 +25,8 @@
 // Include files
 // -----------------------------------------------------------------------------
 
-#include <stdlib.h>
-
 #include "DAConverter.h"
+#include "Voltage.h"
 
 #include "Logger.h"
 
@@ -52,8 +51,6 @@
 // Function declarations
 // -----------------------------------------------------------------------------
 
-static uint32_t calculateDACValue(const struct DAConverter* self, int voltage);
-
 // -----------------------------------------------------------------------------
 // Function definitions
 // -----------------------------------------------------------------------------
@@ -83,7 +80,7 @@ void DAConverter_destruct(struct DAConverter* self)
 
 
 
-extern ErrorStatus DAConverter_setOutputVoltage(const struct DAConverter* self, int voltage)
+ErrorStatus DAConverter_setOutputVoltage(const struct DAConverter* self, int voltage)
 {
    ErrorStatus returnValue = SUCCESS;
    if (returnValue == SUCCESS)
@@ -91,7 +88,7 @@ extern ErrorStatus DAConverter_setOutputVoltage(const struct DAConverter* self,
       if (self->initialized)
       {
          uint32_t dacValue;
-         dacValue = calculateDACValue(self, voltage);
+         dacValue = Voltage_calculateDeviceValue(voltage, self->dacDevice->resolutionInBits, self->minVoltage, self->maxVoltage);
          DACDevice_write(self->dacDevice, dacValue);
       }
    }
@@ -103,23 +100,15 @@ extern ErrorStatus DAConverter_setOutputVoltage(const struct DAConverter* self,
 }
 
 
-static uint32_t calculateDACValue(const struct DAConverter* self, int voltage)
+uint32_t DAConverter_getCurrentValue(const struct DAConverter* self)
 {
-   uint32_t dacValue;
+   uint32_t returnValue = 0;
    if (self->initialized)
    {
-      int maxDacValue = ((1 << self->dacDevice->resolutionInBits) - 1);
+      returnValue = Voltage_calculateVoltage(DACDevice_getCurrentValue(self->dacDevice), self->dacDevice->resolutionInBits, self->minVoltage, self->maxVoltage);
-      int tempValue   = (voltage - self->minVoltage) * maxDacValue;
-      tempValue      /= (self->maxVoltage - self->minVoltage);
-      dacValue = abs(tempValue);
-      if (dacValue > maxDacValue)
-      {
-         dacValue = maxDacValue;
-      }
    }
-   else
+   return returnValue;
-   {
-      dacValue = 0;
-   }
-   return dacValue;
 }
+
+
+

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

@@ -27,6 +27,17 @@
 
 #include "DeviceParameters.h"
 
+#include "hsb-mrts.h"
+#include "Error.h"
+#include "PIDParameters.h"
+#include "PIN.h"
+
+#include "CachedStorage.h"
+#include "crc32.h"
+#include "Logger.h"
+#include "MemoryDevice.h"
+
+
 // -----------------------------------------------------------------------------
 // Constant and macro definitions
 // -----------------------------------------------------------------------------
@@ -42,6 +53,8 @@ struct DeviceParameters
    bool initialized;
    struct CachedStorage* parametersStorage;
    struct MemoryDevice* memoryDevice;
+   unsigned int PIDParametersOffset;
+   unsigned int PINOffset;
 };
 
 struct PIDParametersStorageClass
@@ -60,14 +73,14 @@ struct PINStorageClass
 // File-scope variables
 // -----------------------------------------------------------------------------
 
-static struct DeviceParameters _self      = {.initialized = false};
+static struct DeviceParameters _dParam    = {.initialized = false};
-struct DeviceParameters* const self       = &_self;
+struct DeviceParameters* const dParam      = &_dParam;
 
 // -----------------------------------------------------------------------------
 // Function declarations
 // -----------------------------------------------------------------------------
 
-
+static void DeviceParameters_verifyCRCs(void);
 
 // -----------------------------------------------------------------------------
 // Function definitions
@@ -76,13 +89,14 @@ struct DeviceParameters* const self       = &_self;
 ErrorStatus DeviceParameters_construct(struct CachedStorage* parametersStorage, struct MemoryDevice* memoryDevice)
 {
    ErrorStatus returnValue = SUCCESS;
-   if (!self->initialized)
+
+   if (!dParam->initialized)
    {
       if (returnValue == SUCCESS)
       {
          if (parametersStorage != NULL)
          {
-            self->parametersStorage = parametersStorage;
+            dParam->parametersStorage = parametersStorage;
          }
          else
          {
@@ -96,7 +110,7 @@ ErrorStatus DeviceParameters_construct(struct CachedStorage* parametersStorage,
          {
             if (memoryDevice->initialized)
             {
-               self->memoryDevice = memoryDevice;
+               dParam->memoryDevice = memoryDevice;
             }
             else
             {
@@ -108,7 +122,95 @@ ErrorStatus DeviceParameters_construct(struct CachedStorage* parametersStorage,
             returnValue = ERROR;
          }
       }
-      self->initialized = true;
+
+      if (returnValue == SUCCESS)
+      {
+         // Create new cachedStorage with preset page number
+         returnValue = CachedStorage_construct(dParam->parametersStorage, dParam->memoryDevice, APP_FLASH_PARAMETERS_PAGE, (sizeof(struct PIDParametersStorageClass) + sizeof(struct PINStorageClass)) / 4);
+      }
+
+      if (returnValue == SUCCESS)
+      {
+         dParam->PIDParametersOffset  = 0;
+         dParam->PINOffset            = sizeof(struct PIDParametersStorageClass) / 4;
+         dParam->initialized          = true;
+      }
+
+      // Check the CRC on the loaded parameters
+      // If a CRC fails, corrupted data will automatically be replaced with defaults
+      if (returnValue == SUCCESS)
+      {
+         DeviceParameters_verifyCRCs();
+      }
+
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+
+   return returnValue;
+}
+
+
+void DeviceParameters_destruct(void)
+{
+   if (dParam->initialized)
+   {
+      CachedStorage_destruct(dParam->parametersStorage);
+      dParam->parametersStorage  = NULL;
+      dParam->memoryDevice       = NULL;
+   }
+}
+
+
+struct PIDParameters* DeviceParameters_getPIDParameters(void)
+{
+   struct PIDParameters* returnValue = NULL;
+   if (dParam->initialized)
+   {
+      struct PIDParametersStorageClass* tempValue;
+      tempValue = (struct PIDParametersStorageClass*)CachedStorage_readBlob(dParam->parametersStorage, dParam->PIDParametersOffset);
+      returnValue = &tempValue->pidParameters;
+   }
+   return returnValue;
+}
+
+
+struct PIN* DeviceParameters_getPIN(void)
+{
+   struct PIN* returnValue = NULL;
+   if (dParam->initialized)
+   {
+      struct PINStorageClass* tempValue;
+      tempValue = (struct PINStorageClass*)CachedStorage_readBlob(dParam->parametersStorage, dParam->PINOffset);
+      returnValue = &tempValue->pin;
+   }
+   return returnValue;
+}
+
+
+void DeviceParameters_saveParameters(void)
+{
+   if (dParam->initialized)
+   {
+      // Commit cache to memory - will not write if no changes have been made
+      CachedStorage_commit(dParam->parametersStorage);
+   }
+}
+
+
+ErrorStatus DeviceParameters_writePIDParameters(struct PIDParameters* parameters)
+{
+   ErrorStatus returnValue = SUCCESS;
+   if (dParam->initialized)
+   {
+      struct PIDParametersStorageClass tempPIDStorage;
+      tempPIDStorage.pidParameters = *parameters;
+      // Calculate CRC over preset
+      tempPIDStorage.crc = crc32_calculate(0, &tempPIDStorage.pidParameters, sizeof(struct PIDParameters));
+      // Put default preset on Cache
+      CachedStorage_writeBlob(dParam->parametersStorage, dParam->PIDParametersOffset, &tempPIDStorage, sizeof(struct PIDParametersStorageClass) / 4);
    }
    else
    {
@@ -118,19 +220,70 @@ ErrorStatus DeviceParameters_construct(struct CachedStorage* parametersStorage,
 }
 
 
-void DeviceParameters_destruct(void)
+ErrorStatus DeviceParameters_writePIN(struct PIN* pin)
 {
-
+   ErrorStatus returnValue = SUCCESS;
+   if (dParam->initialized)
+   {
+      struct PINStorageClass tempPINStorage;
+      tempPINStorage.pin = *pin;
+      // Calculate CRC over preset
+      tempPINStorage.crc = crc32_calculate(0, &tempPINStorage.pin, sizeof(struct PIN));
+      // Put default preset on Cache
+      CachedStorage_writeBlob(dParam->parametersStorage, dParam->PINOffset, &tempPINStorage, sizeof(struct PINStorageClass) / 4);
+   }
+   else
+   {
+      returnValue = ERROR;
+   }
+   return returnValue;
 }
 
 
-struct PIDParameters* DeviceParameters_getPIDParameters(void)
+static void DeviceParameters_verifyCRCs(void)
-{
-
-}
-
-
-struct PIN* DeviceParameters_getPIN(void)
 {
+   uint32_t tempCRC;
+   if (dParam->initialized)
+   {
+      // PID PARAMETERS CHECK
+      struct PIDParametersStorageClass _tempPIDParameters;
+      struct PIDParametersStorageClass* tempPIDParameters = &_tempPIDParameters;
+      tempPIDParameters = (struct PIDParametersStorageClass*)CachedStorage_readBlob(dParam->parametersStorage, dParam->PIDParametersOffset);
 
+      // Calculate the CRC of the parameters
+      tempCRC = crc32_calculate(0, &tempPIDParameters->pidParameters, sizeof(struct PIDParameters));
+      // Compare CRC
+      if (tempCRC != tempPIDParameters->crc)
+      {
+         Error_postError(ERROR_CRC_PARAMETERS);
+         // CRC do not match
+         LOGGER_ERROR(mainLog, "CRC ERROR at Device Parameters (calculated %X but loaded %X)", (unsigned int)tempCRC, (unsigned int)tempPIDParameters->crc);
+         // Replace corrupt Device parameters with defaults
+         PIDParameters_generateDefaultParameters(&tempPIDParameters->pidParameters);
+         // Write parameters to cache including the CRC (calculated inside write function)
+         DeviceParameters_writePIDParameters(&tempPIDParameters->pidParameters);
+      }
+
+
+      // PIN CHECK
+      struct PINStorageClass _tempPIN;
+      struct PINStorageClass* tempPIN = &_tempPIN;
+      tempPIN = (struct PINStorageClass*)CachedStorage_readBlob(dParam->parametersStorage, dParam->PINOffset);
+
+      // Calculate the CRC of the PIN
+      // Calculate the CRC of the parameters
+      tempCRC = crc32_calculate(0, &tempPIN->pin, sizeof(struct PIN));
+      // Compare CRC
+      if (tempCRC != tempPIN->crc)
+      {
+         Error_postError(ERROR_CRC_PIN);
+         // CRC do not match
+         LOGGER_ERROR(mainLog, "CRC ERROR at Device PIN (calculated %X but loaded %X)", (unsigned int)tempCRC, (unsigned int)tempPIN->crc);
+         // Replace corrupt Device parameters with defaults
+         PIN_generateDefaultPIN(&tempPIN->pin);
+         // Write parameters to cache including the CRC (calculated inside write function)
+         DeviceParameters_writePIN(&tempPIN->pin);
+      }
+      DeviceParameters_saveParameters();
+   }
 }

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

@@ -117,3 +117,5 @@ static ErrorStatus Displays_mainDisplayObserverFromISR(const void* const data)
    Display_feedRefreshCounterFromISR(mainDisplay);
    return SUCCESS;
 }
+
+

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

@@ -25,6 +25,8 @@
 // Include files
 // -----------------------------------------------------------------------------
 
+#include <string.h>
+
 #include "MenuCore.h"
 
 #include "Logger.h"
@@ -117,6 +119,7 @@ ErrorStatus MenuCore_construct(struct MenuCore* self, struct Display* display, s
             self->scrollOffset         = 0;
             self->cursorIndex          = 1;
             self->menuState            = 0;
+            self->insertString[0]      = '\0';
             // Menu core is initialised - Menu core is good to go
             self->initialized          = true;
          }
@@ -154,7 +157,10 @@ static void MenuCore_task(void* parameters)
       Keypad_KeyState keyState;
 
       // Take care of potential actions that must be taken prior to reading the keyboard/input
-      self->_handleStateFunction(self);
+      if (self->_handleStateFunction != NULL)
+      {
+         self->_handleStateFunction(self);
+      }
 
       if (KeyboardDevice_read(self->keyboardDevice, &key, &keyState) == SUCCESS)
       {
@@ -162,7 +168,7 @@ static void MenuCore_task(void* parameters)
          {
             // The key had an action
             // Clear the screen for a new menu
-            Display_clearScreen(self->display);
+//            Display_clearScreen(self->display);
             // Print menu content to output device
             MenuCore_printMenu(self);
             // Add cursor if necessary
@@ -200,6 +206,7 @@ static void MenuCore_printMenu(struct MenuCore* self)
 
    for (loopCounter = 1 ; loopCounter < self->display->displayDevice->parameters.numberOfRows; loopCounter++)
    {
+      Display_clearLine(self->display, loopCounter + 1);
       Display_write(self->display, self->menuArray[self->menuState].row[loopCounter + self->scrollOffset].text, loopCounter + 1, 1);
    }
 }
@@ -284,46 +291,26 @@ static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypa
       }
       case DIGIT_INSERT:
       {
-         LOGGER_INFO(mainLog, "Key is allowed as insert");
+         int numberOfDigits = strlen(self->insertString);
-
-         // Determine the number of digits currently used
-         int divider = self->insertValue;
-         int numberOfDigits = 0;
-         while (divider != 0)
-         {
-            divider /= 10;
-            numberOfDigits++;
-         }
-
          // The Argument carries the max number of digits for the current insertion value
          if (numberOfDigits < keyAction.argument)
          {
-            // Verify that only digits 0-9 are taken into account
+            // Attach latest character to string
-            // Copare with decimal ASCII
+            strncat(self->insertString, &keyAction.key, 1);
-            if ((keyAction.key > 47) && (keyAction.key < 58))
-            {
-               // Shift the already inserted value to the left
-               self->insertValue = self->insertValue * 10;
-               // Add the latest value
-               self->insertValue = self->insertValue + (keyAction.key - 48);
-            }
          }
-         LOGGER_INFO(mainLog, "Inserted Value is: %d", self->insertValue);
          break;
       }
 
       case DIGIT_REMOVE:
       {
-         LOGGER_INFO(mainLog, "Key is allowed as remove");
          // Shift the already inserted value to the right
-         self->insertValue = self->insertValue / 10;
+         int numberOfDigits = strlen(self->insertString);
-         LOGGER_INFO(mainLog, "Inserted Value is: %d", self->insertValue);
+         self->insertString[numberOfDigits - 1] = '\0';
          break;
       }
 
       case DIGIT_INSERT_CONFIRM:
       {
-         LOGGER_INFO(mainLog, "Digit insert confirmed");
          if (keyAction.actionPointer != NULL)
          {
             keyAction.actionPointer(self);

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

@@ -0,0 +1,108 @@
+// -----------------------------------------------------------------------------
+/// @file  PIDParameters.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 PIDParameters.c
+/// @ingroup {group_name}
+
+
+// -----------------------------------------------------------------------------
+// Include files
+// -----------------------------------------------------------------------------
+
+#include "PIDParameters.h"
+
+#include "PCBA.h"
+#include "PID.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions
+// -----------------------------------------------------------------------------
+
+
+// -----------------------------------------------------------------------------
+// File-scope variables
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function definitions
+// -----------------------------------------------------------------------------
+
+void PIDParameters_generateDefaultParameters(struct PIDParameters* self)
+{
+   // Differ between positive and negative regulation
+   if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
+   {
+      // Negative regulation
+      self->iMin  = -100000000;
+      self->iMax  = 0;
+   }
+   else
+   {
+      // positive regulation
+      self->iMin  = 0;
+      self->iMax  = 100000000;
+   }
+   self->Kp    = 3 * PID_FIXED_POINT_FACTOR / 10;
+   self->Ki    = 2 * PID_FIXED_POINT_FACTOR / 10;
+   self->Kd    = 0 * PID_FIXED_POINT_FACTOR / 10;
+}
+
+
+void PIDParameters_setKp(struct PIDParameters* self, int Kp)
+{
+   self->Kp = Kp;
+}
+
+
+void PIDParameters_setKi(struct PIDParameters* self, int Ki)
+{
+   self->Ki = Ki;
+}
+
+
+ void PIDParameters_setKd(struct PIDParameters* self, int Kd)
+ {
+    self->Kd = Kd;
+ }
+
+
+void PIDParameters_setiMin(struct PIDParameters* self, int iMin)
+{
+   self->iMin = iMin;
+}
+
+
+void PIDParameters_setiMax(struct PIDParameters* self, int iMax)
+{
+   self->iMax = iMax;
+}

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

@@ -0,0 +1,142 @@
+// -----------------------------------------------------------------------------
+/// @file  PIN.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 PIN.c
+/// @ingroup {group_name}
+
+
+// -----------------------------------------------------------------------------
+// Include files
+// -----------------------------------------------------------------------------
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "PIN.h"
+
+#include "Logger.h"
+// -----------------------------------------------------------------------------
+// Constant and macro definitions
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions
+// -----------------------------------------------------------------------------
+
+
+// -----------------------------------------------------------------------------
+// File-scope variables
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations
+// -----------------------------------------------------------------------------
+
+static ErrorStatus PIN_verifyInsertedPins(struct PIN* self);
+
+// -----------------------------------------------------------------------------
+// Function definitions
+// -----------------------------------------------------------------------------
+
+
+void PIN_generateDefaultPIN(struct PIN* self)
+{
+   self->firstDigit     = 0;
+   self->secondDigit    = 1;
+   self->thirdDigit     = 2;
+   self->fourthDigit    = 3;
+}
+
+
+bool PIN_isOK(struct PIN* self, char* const pin)
+{
+   bool returnValue = false;
+
+   if (pin[0] == self->firstDigit)
+   {
+      if (pin[1] == self->secondDigit)
+      {
+         if (pin[2] == self->thirdDigit)
+         {
+            if (pin[3] == self->fourthDigit)
+            {
+               returnValue = true;
+            }
+         }
+      }
+   }
+   return returnValue;
+}
+
+
+void PIN_changePinFirstInsert(struct PIN* self, char* const firstPinInsert)
+{
+   int loopCounter;
+   if (firstPinInsert != NULL)
+   {
+      for (loopCounter = 0; loopCounter < PIN_NUMBER_OF_DIGITS; loopCounter++)
+      {
+         self->pinchangeFirstInsert[loopCounter] = firstPinInsert[loopCounter];
+      }
+   }
+}
+
+
+ErrorStatus PIN_changePinSecondInsert(struct PIN* self, char* const secondPinInsert)
+{
+   ErrorStatus returnValue = SUCCESS;
+
+   int loopCounter;
+   if (secondPinInsert != NULL)
+   {
+      for (loopCounter = 0; loopCounter < PIN_NUMBER_OF_DIGITS; loopCounter++)
+      {
+         self->pinchangeSecondInsert[loopCounter] = secondPinInsert[loopCounter];
+      }
+   }
+
+   returnValue = PIN_verifyInsertedPins(self);
+   // Verify both PINs
+   if (returnValue == SUCCESS)
+   {
+      self->firstDigit  = self->pinchangeFirstInsert[0];
+      self->secondDigit = self->pinchangeFirstInsert[1];
+      self->thirdDigit  = self->pinchangeFirstInsert[2];
+      self->fourthDigit = self->pinchangeFirstInsert[3];
+   }
+
+   return returnValue;
+}
+
+
+static ErrorStatus PIN_verifyInsertedPins(struct PIN* self)
+{
+   ErrorStatus returnValue = SUCCESS;
+
+   if(memcmp(self->pinchangeFirstInsert, self->pinchangeSecondInsert, PIN_NUMBER_OF_DIGITS != 0))
+   {
+      // Inserted PINs are not equal
+      returnValue = ERROR;
+   }
+   return returnValue;
+}

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

@@ -61,7 +61,15 @@ ErrorStatus RepairPreset_generateDefaultPreset(struct RepairPreset* self, unsign
    }
    else
    {
-      self->numberOfStages             = 2;
+      // TELSA PCBA does not need multiple stages
+      if (PCBA_getInstance()->pcba == PCBA_Tesla)
+      {
+         self->numberOfStages          = 1;
+      }
+      else
+      {
+         self->numberOfStages             = 2;
+      }
    }
    self->presetNumber                  = presetNumber;
    self->preset[0].softstartDuration   = 1800;

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

@@ -28,6 +28,7 @@
 #include <stdbool.h>
 
 #include "hsb-mrts.h"
+#include "Error.h"
 #include "RepairPresets.h"
 
 #include "CachedStorage.h"
@@ -72,7 +73,7 @@ struct RepairPresets* const self       = &_self;
 // Function declarations
 // -----------------------------------------------------------------------------
 
-static ErrorStatus RepairPresets_verifyCRCs(void);
+static void RepairPresets_verifyCRCs(void);
 static ErrorStatus RepairPresets_verifyPresetCRC(struct RepairPresetStorageClass* repairPreset);
 
 // -----------------------------------------------------------------------------
@@ -193,7 +194,7 @@ ErrorStatus RepairPresets_loadPresets(REPAIR_PRESETS_ID presetID)
       // Check the CRC on the loaded presets
       if (returnValue == SUCCESS)
       {
-         returnValue = RepairPresets_verifyCRCs();
+         RepairPresets_verifyCRCs();
       }
 
       // CRCs are verified
@@ -225,7 +226,7 @@ struct RepairPreset* RepairPresets_getPreset(unsigned int index)
          if ((index > 0) || (index <= REPAIR_PRESETS_NUMBER_OF_PRESETS))
          {
             struct RepairPresetStorageClass* tempPreset;
-            tempPreset = CachedStorage_readBlob(self->presetStorage, (index - 1) * sizeof(struct RepairPresetStorageClass) / 4);
+            tempPreset = (struct RepairPresetStorageClass*)CachedStorage_readBlob(self->presetStorage, (index - 1) * sizeof(struct RepairPresetStorageClass) / 4);
             returnValue = (struct RepairPreset*)&tempPreset->preset;
          }
       }
@@ -241,7 +242,7 @@ void RepairPresets_savePresets(void)
 }
 
 
-static ErrorStatus RepairPresets_verifyCRCs(void)
+static void RepairPresets_verifyCRCs(void)
 {
    ErrorStatus returnValue = SUCCESS;
    if (self->initialized)
@@ -249,15 +250,17 @@ static ErrorStatus RepairPresets_verifyCRCs(void)
       int loopCounter;
       struct RepairPresetStorageClass _tempPresetStorage;
       struct RepairPresetStorageClass* tempPresetStorage = &_tempPresetStorage;
+      bool crcErrorFound = false;
       for (loopCounter = 0; loopCounter < REPAIR_PRESETS_NUMBER_OF_PRESETS; loopCounter++)
       {
          // Load next preset from cache
-         tempPresetStorage = CachedStorage_readBlob(self->presetStorage, loopCounter * sizeof(struct RepairPresetStorageClass) / 4);
+         tempPresetStorage = (struct RepairPresetStorageClass*)CachedStorage_readBlob(self->presetStorage, loopCounter * sizeof(struct RepairPresetStorageClass) / 4);
          // Verify CRC
          returnValue = RepairPresets_verifyPresetCRC(tempPresetStorage);
          // Check CRC verification
          if (returnValue != SUCCESS)
          {
+            crcErrorFound = true;
             // 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);
@@ -265,14 +268,13 @@ static ErrorStatus RepairPresets_verifyCRCs(void)
             RepairPresets_writePreset(&tempPresetStorage->preset);
          }
       }
+      if (crcErrorFound)
+      {
+         Error_postError(ERROR_CRC_PRESETS);
+      }
       // Commit cache to memory - will not write if no changes have been made
       CachedStorage_commit(self->presetStorage);
    }
-   else
-   {
-      returnValue = ERROR;
-   }
-   return returnValue;
 }
 
 

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

@@ -70,10 +70,28 @@ ErrorStatus SignalProfileGenerator_construct(struct SignalProfileGenerator* self
 
    if (!self->initialized)
    {
-      self->secondsCounter = 0;
+      self->secondsCounter       = 0;
-      self->currentState   = SPG_PREPARE;
+      self->currentPresetIndex   = 0;
-      self->initialized    = true;
+      self->currentState         = SPG_PREPARE;
-      self->repairPreset   = preset;
+      self->initialized          = true;
+      self->isProcessRunning     = false;
+      self->repairPreset         = preset;
+      self->signal               = 0;
+      self->statePriorToPause    = SPG_PREPARE;
+      self->totalRunTime         = 0;
+      self->totalStartTime       = 0;
+
+      self->pauseSoftStartTimer  = 0;
+      self->pauseStartTime       = 0;
+      self->pauseStartVoltage    = 0;
+
+      self->softStartTimer       = 0;
+      self->startTime            = 0;
+      self->startVoltage         = 0;
+
+      self->voltageHoldTimer     = 0;
+      self->voltagePriorToPause  = 0;
+
    }
    else
    {
@@ -91,10 +109,10 @@ void SignalProfileGenerator_destruct(struct SignalProfileGenerator* self)
 
 void SignalProfileGenerator_calculate(struct SignalProfileGenerator* self)
 {
-   self->signal = 0;
 
    if (self->initialized)
    {
+
       switch (self->currentState)
       {
          case SPG_PREPARE:
@@ -103,13 +121,30 @@ void SignalProfileGenerator_calculate(struct SignalProfileGenerator* self)
             //Load the timers
             self->startTime         = self->secondsCounter;
             self->softStartTimer    = self->secondsCounter + self->repairPreset->preset[self->currentPresetIndex].softstartDuration;
-            self->voltageHoldTimer  = self->secondsCounter + self->repairPreset->preset[self->currentPresetIndex].duration;
+            self->voltageHoldTimer  = self->secondsCounter + self->repairPreset->preset[self->currentPresetIndex].duration + self->repairPreset->preset[self->currentPresetIndex].softstartDuration;
 
-            LOGGER_DEBUG(mainLog, "startTime %d - softStartTime %d - HoldTimer %d", (unsigned int)self->startTime, (unsigned int)self->softStartTimer, (unsigned int)self->voltageHoldTimer);
+            // Calculate the complete timer for ALL stages - but only when in first stage, so this
-
+            // calculation does not get re-done with every new stage
-            // If first preset, start voltage is 0
             if (self->currentPresetIndex == 0)
             {
+               // RESET the total runtime prior to new calculation
+               // Take the current time (starttime) as offset
+               self->totalStartTime = self->startTime;
+               self->totalRunTime   = self->startTime;
+               // The total run-time is the sum of all softstart times and hold times
+               int loopcounter;
+               for (loopcounter = 0; loopcounter < self->repairPreset->numberOfStages; loopcounter++)
+               {
+                  self->totalRunTime += self->repairPreset->preset[loopcounter].softstartDuration;
+                  self->totalRunTime += self->repairPreset->preset[loopcounter].duration;
+               }
+            }
+
+            // If first preset, start voltage is 0 (or the representative 0-offset values per PCBA)
+            if (self->currentPresetIndex == 0)
+            {
+               // RESET the signal to 0 at the very start of a new signalprofile
+               self->signal = 0;
                if (PCBA_getInstance()->pcba == PCBA_Anode)
                {
                   self->startVoltage = SPG_0V_OFFSET_ANODE;
@@ -172,10 +207,11 @@ void SignalProfileGenerator_calculate(struct SignalProfileGenerator* self)
          {
             self->pauseStartTime       = self->secondsCounter;
             self->pauseSoftStartTimer  = self->secondsCounter + SPG_PAUSE_SOFTSTART;
-            self->startTime            = self->startTime + SPG_PAUSE_SOFTSTART;
             self->softStartTimer       = self->softStartTimer + SPG_PAUSE_SOFTSTART;
             self->voltageHoldTimer     = self->voltageHoldTimer + SPG_PAUSE_SOFTSTART;
             self->currentState         = SPG_PAUSE_RESTORE_SOFTSTART;
+            // Add the pause time twice because the total time actually increases
+            self->totalRunTime         = self->totalRunTime + SPG_PAUSE_SOFTSTART;
             break;
          }
          case SPG_PAUSE_RESTORE_SOFTSTART:
@@ -226,6 +262,7 @@ void SignalProfileGenerator_calculate(struct SignalProfileGenerator* self)
             }
             break;
          }
+
          case SPG_FINISHED:
          {
             self->isProcessRunning = false;
@@ -264,6 +301,21 @@ bool SignalProfileGenerator_isPaused(struct SignalProfileGenerator* self)
 }
 
 
+bool SignalProfileGenerator_isFinished(struct SignalProfileGenerator* self)
+{
+   bool returnValue;
+   if (self->currentState == SPG_FINISHED)
+   {
+      returnValue = true;
+   }
+   else
+   {
+      returnValue = false;
+   }
+   return returnValue;
+}
+
+
 void SignalProfileGenerator_continue(struct SignalProfileGenerator* self)
 {
    self->currentState = SPG_PAUSE_RESTORE;
@@ -276,9 +328,10 @@ uint32_t SignalProfileGenerator_getRemainingTime(const struct SignalProfileGener
 
    if ((self->initialized) && (self->isProcessRunning))
    {
-      if (self->voltageHoldTimer >= self->secondsCounter)
+
+      if (self->totalRunTime >= self->secondsCounter)
       {
-         returnValue = (self->voltageHoldTimer - self->secondsCounter);
+         returnValue = (self->totalRunTime - self->secondsCounter);
       }
       else
       {
@@ -294,6 +347,22 @@ uint32_t SignalProfileGenerator_getRemainingTime(const struct SignalProfileGener
 }
 
 
+uint32_t SignalProfileGenerator_getTotalRepairTime(const struct SignalProfileGenerator* self)
+{
+   uint32_t returnValue;
+
+   if ((self->initialized) && (self->isProcessRunning))
+   {
+         returnValue = (self->totalRunTime - self->totalStartTime);
+   }
+   else
+   {
+      returnValue = 0xFFFFFFFF;
+   }
+   return returnValue;
+}
+
+
 static inline void incrementSecondsCounter(struct SignalProfileGenerator* self)
 {
    self->secondsCounter++;

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

@@ -0,0 +1,114 @@
+// -----------------------------------------------------------------------------
+/// @file  Voltage.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 Voltage.c
+/// @ingroup {group_name}
+
+
+// -----------------------------------------------------------------------------
+// Include files
+// -----------------------------------------------------------------------------
+
+#include <stdlib.h>
+
+#include "Voltage.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Type definitions
+// -----------------------------------------------------------------------------
+
+
+// -----------------------------------------------------------------------------
+// File-scope variables
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function declarations
+// -----------------------------------------------------------------------------
+
+
+
+// -----------------------------------------------------------------------------
+// Function definitions
+// -----------------------------------------------------------------------------
+
+
+int Voltage_calculateVoltage(uint32_t value, uint32_t resolutionInBits, int minVoltage, int maxVoltage)
+{
+   int returnValue = 0;
+
+   int maxAdcValue = ((1 << resolutionInBits) - 1);
+
+   returnValue = (int)value * (maxVoltage - minVoltage);
+   returnValue = returnValue / maxAdcValue;
+    returnValue = returnValue + minVoltage;
+
+
+   // Differ between an positive and negative scale
+   if (maxVoltage > minVoltage)
+   {
+      // Common scale with a higher maximum value than the minimum value
+      if (returnValue < minVoltage)
+      {
+         returnValue = minVoltage;
+      }
+      else if (returnValue > maxVoltage)
+      {
+         returnValue = maxVoltage;
+      }
+   }
+   else
+   {
+      // Negative scale where the ADC value (positive) must be translated in a negative voltage
+      if (returnValue > minVoltage)
+      {
+         returnValue = minVoltage;
+      }
+      else if (returnValue < maxVoltage)
+      {
+         returnValue = maxVoltage;
+      }
+   }
+   return returnValue;
+}
+
+
+uint32_t Voltage_calculateDeviceValue(int value, uint32_t resolutionInBits, int minVoltage, int maxVoltage)
+{
+   uint32_t dacValue;
+
+   int maxDacValue = ((1 << resolutionInBits) - 1);
+   int tempValue   = (value - minVoltage) * maxDacValue;
+   tempValue       = tempValue / (maxVoltage - minVoltage) + 1;
+   dacValue = abs(tempValue);
+   if (dacValue > maxDacValue)
+   {
+      dacValue = maxDacValue;
+   }
+
+   return dacValue;
+}

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

@@ -0,0 +1,115 @@
+// -----------------------------------------------------------------------------
+/// @file  Warning.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 Warning.c
+/// @ingroup {group_name}
+
+
+// -----------------------------------------------------------------------------
+// Include files
+// -----------------------------------------------------------------------------
+
+#include "Warning.h"
+
+#include "platform.h"
+#include "Logger.h"
+
+// -----------------------------------------------------------------------------
+// Constant and macro definitions
+// -----------------------------------------------------------------------------
+
+#define WARNING_QUEUE_SIZE               (10)
+
+
+// -----------------------------------------------------------------------------
+// Type definitions
+// -----------------------------------------------------------------------------
+
+struct WarningQueueItem
+{
+   T_WarningCode warningCode;
+};
+
+// -----------------------------------------------------------------------------
+// File-scope variables
+// -----------------------------------------------------------------------------
+
+static struct Observable observable;
+static TaskHandle_t warningTaskHandle;
+static QueueHandle_t warningQueue;
+
+// -----------------------------------------------------------------------------
+// Function declarations
+// -----------------------------------------------------------------------------
+
+static void WarningTask (void* parameters);
+
+// -----------------------------------------------------------------------------
+// Function definitions
+// -----------------------------------------------------------------------------
+
+
+ErrorStatus Warning_construct(void)
+{
+   Observable_construct(&observable);
+
+   warningQueue = xQueueCreate(WARNING_QUEUE_SIZE, sizeof(struct WarningQueueItem));
+   xTaskCreate(WarningTask, "ErrorTask", 300, NULL, 1, &warningTaskHandle);
+
+   return SUCCESS;
+}
+
+
+struct Observable* Warning_getObservable(void)
+{
+   return &observable;
+}
+
+
+void Warning_postWarning(T_WarningCode warningCode)
+{
+   LOGGER_WARNING(mainLog, "WARNING POSTED WITH CODE %d", warningCode);
+   struct WarningQueueItem queueItem;
+   queueItem.warningCode = warningCode;
+   xQueueSend(warningQueue, &queueItem, 0);
+}
+
+
+void Warning_postWarningFromISR(T_WarningCode warningCode)
+{
+   portBASE_TYPE higherPriorityTaskWoken = pdFALSE;
+   LOGGER_WARNING_ISR(mainLog, "WARNING POSTED FROM ISR");
+
+   struct WarningQueueItem queueItem;
+   queueItem.warningCode = warningCode;
+   xQueueSendFromISR(warningQueue, &queueItem, &higherPriorityTaskWoken);
+
+   portEND_SWITCHING_ISR(higherPriorityTaskWoken);
+}
+
+
+static void WarningTask (void* parameters)
+{
+   struct WarningQueueItem queueItem;
+   while (1)
+   {
+      xQueueReceive(warningQueue, &queueItem, portMAX_DELAY);
+      Observable_notifyObservers(&observable, (const void* const)queueItem.warningCode);
+   }
+}

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

@@ -36,6 +36,7 @@
 #include "DAConverters.h"
 #include "Display.h"
 #include "Error.h"
+#include "Warning.h"
 
 #include "platform.h"
 #include "CoverSolenoid.h"
@@ -43,6 +44,7 @@
 #include "Logger.h"
 #include "PCBA.h"
 #include "Power6V5Supply.h"
+#include "TeslaGunSafety.h"
 #include "Version.h"
 
 // -----------------------------------------------------------------------------
@@ -60,7 +62,7 @@
 // File-scope variables
 // -----------------------------------------------------------------------------
 
-
+static bool _hsb_safetyIsEnabled = false;
 
 // -----------------------------------------------------------------------------
 // Function declarations
@@ -104,7 +106,7 @@ ErrorStatus hsb_generateStartScreen(struct Display* Display)
 }
 
 
-ErrorStatus hsb_enableSafety(void)
+ErrorStatus hsb_enableSafetyWithError(void)
 {
    ErrorStatus returnValue = SUCCESS;
 
@@ -117,8 +119,7 @@ ErrorStatus hsb_enableSafety(void)
    if (returnValue == SUCCESS)
    {
       // Check for INTERLOCK CLOSE
-//      if (Interlock_isClosed(interlock))
+      if (Interlock_isClosed(interlock))
-      if (1)
       {
          // Enable Interrupt for interlock switch
          Interlock_setEXTI(interlock, ENABLE);
@@ -130,11 +131,82 @@ ErrorStatus hsb_enableSafety(void)
       }
    }
 
+   if (returnValue == SUCCESS)
+   {
+      // In case of a TESLA repair, release the teslaGunSafety
+      if (PCBA_getInstance()->pcba == PCBA_Tesla)
+      {
+         TeslaGunSafety_release();
+      }
+   }
+
    // if Interlock(s) closed, continue procedure
    if (returnValue == SUCCESS)
    {
       // Power the circuit
-      Power6V5Supply_on();
+      returnValue = Power6V5Supply_on();
+   }
+
+   if (returnValue == SUCCESS)
+   {
+      _hsb_safetyIsEnabled = true;
+   }
+   else
+   {
+      _hsb_safetyIsEnabled = false;
+   }
+   return returnValue;
+}
+
+
+ErrorStatus hsb_enableSafetyWithWarning(void)
+{
+   ErrorStatus returnValue = SUCCESS;
+
+   // First, Lock the cover
+   if (returnValue == SUCCESS)
+   {
+      CoverSolenoid_lock();
+   }
+
+   if (returnValue == SUCCESS)
+   {
+      // Check for INTERLOCK CLOSE
+      if (Interlock_isClosed(interlock))
+      {
+         // Enable Interrupt for interlock switch
+         Interlock_setEXTI(interlock, ENABLE);
+      }
+      else
+      {
+         Warning_postWarning(WARNING_INTERLOCK_COMMON_FAIL);
+         returnValue = ERROR;
+      }
+   }
+
+   if (returnValue == SUCCESS)
+   {
+      // In case of a TESLA repair, release the teslaGunSafety
+      if (PCBA_getInstance()->pcba == PCBA_Tesla)
+      {
+         TeslaGunSafety_release();
+      }
+   }
+
+   // if Interlock(s) closed, continue procedure
+   if (returnValue == SUCCESS)
+   {
+      // Power the circuit
+      returnValue = Power6V5Supply_on();
+   }
+
+   if (returnValue == SUCCESS)
+   {
+      _hsb_safetyIsEnabled = true;
+   }
+   else
+   {
+      _hsb_safetyIsEnabled = false;
    }
    return returnValue;
 }
@@ -148,16 +220,19 @@ ErrorStatus hsb_disableSafety(void)
    int adcR2Value = HSB_SECURITY_VOLTAGE_THRESHOLD;
    int adcR3Value = HSB_SECURITY_VOLTAGE_THRESHOLD;
 
-   Display_clearScreen(mainDisplay);
+   if (PCBA_getInstance()->pcba == PCBA_Tesla)
+   {
+      TeslaGunSafety_block();
+   }
+
+//   Display_clearScreen(mainDisplay);
    char buffer[mainDisplay->displayDevice->parameters.numberOfColumns];
    snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "WAITING FOR");
-   Display_write(mainDisplay, buffer, 2, 5);
+   Display_write(mainDisplay, buffer, 3, 5);
 
-   snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "POWER");
+   snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "POWER DOWN");
-   Display_write(mainDisplay, buffer, 3, 7);
+   Display_write(mainDisplay, buffer, 4, 6);
 
-   snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "DOWN");
-   Display_write(mainDisplay, buffer, 4, 8);
 
    // Power-down the DAC outputs
    DAConverter_setOutputVoltage(dacRow1, 0);
@@ -167,18 +242,40 @@ ErrorStatus hsb_disableSafety(void)
    // Un-Power the circuit
    Power6V5Supply_off();
 
-
+   if (PCBA_getInstance()->pcba != PCBA_Tesla)
-   // Verify that all High Voltage Supplies are shut off and voltages are below security value
-   while ((abs(adcR1Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD) || (abs(adcR2Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD) || (abs(adcR3Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD))
    {
-      adcR1Value = ADConverter_getInputVoltage(adcRow1);
+      // Verify that all High Voltage Supplies are shut off and voltages are below security value
-      adcR2Value = ADConverter_getInputVoltage(adcRow2);
+      while ((abs(adcR1Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD) || (abs(adcR2Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD) || (abs(adcR3Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD))
-      adcR3Value = ADConverter_getInputVoltage(adcRow3);
+      {
-      vTaskDelay(100);
+         adcR1Value = ADConverter_getInputVoltage(adcRow1);
+         adcR2Value = ADConverter_getInputVoltage(adcRow2);
+         adcR3Value = ADConverter_getInputVoltage(adcRow3);
+         vTaskDelay(100);
+      }
    }
+   else
+   {
+      // Verify that all High Voltage Supplies are shut off and voltages are below security value
+      while (abs(adcR2Value) >= HSB_SECURITY_VOLTAGE_THRESHOLD)
+      {
+         adcR2Value = ADConverter_getInputVoltage(adcRow2);
+         vTaskDelay(100);
+      }
+   }
+
+   Display_clearLine(mainDisplay, 3);
+   Display_clearLine(mainDisplay, 4);
 
 
    Interlock_setEXTI(interlock, DISABLE);
 
+   _hsb_safetyIsEnabled = false;
+
    return returnValue;
 }
+
+
+bool hsb_safetyIsEnabled(void)
+{
+   return _hsb_safetyIsEnabled;
+}

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

@@ -35,6 +35,7 @@
 
 #include "ADConverters.h"
 #include "DAConverters.h"
+#include "DeviceParameters.h"
 #include "Displays.h"
 #include "Error.h"
 #include "hsb-mrts.h"
@@ -43,6 +44,7 @@
 #include "repairMenus.h"
 #include "repairProcess.h"
 #include "repairProcesses.h"
+#include "Warning.h"
 
 #include "misc.h"
 #include "stm32f10x_rcc.h"
@@ -100,12 +102,12 @@ static xTaskHandle initTaskHandle;
 static xTaskHandle ledTaskHandle;
 static xTaskHandle sysTaskHandle;
 
-static struct HwValidationMenu _hwValidation = {.initialized = false};
+//static struct HwValidationMenu _hwValidation = {.initialized = false};
-static struct HwValidationMenuItems hwTestItems;
+//static struct HwValidationMenuItems hwTestItems;
-
+//struct HwValidationMenu* hwValidation = &_hwValidation;
-struct HwValidationMenu* hwValidation = &_hwValidation;
 
 static struct CachedStorage cs = {.initialized = false};
+static struct CachedStorage deviceParameters = {.initialized = false};
 
 // -----------------------------------------------------------------------------
 // Function declarations
@@ -151,7 +153,7 @@ void vApplicationTickHook ()
 
 static void printSystemInfoTask(void* parameters)
 {
-   while (1)
+//   while (1)
    {
       LOGGER_INFO(mainLog, "---------------------------------------");
       systeminfoCommandHandler();
@@ -195,6 +197,9 @@ static void initTask(void* parameters)
    // Create the error handler
    Error_construct();
 
+   // Create the warning handler
+   Warning_construct();
+
    // Initialize the platform first
    // All IO is initialized here
    // Also, all periphery and platform-specifics are initialized here
@@ -213,13 +218,15 @@ static void initTask(void* parameters)
    // Construct the DA Converters
    DAConverters_construct();
 
-   // Construct the repair presets
-   RepairPresets_construct(&cs, &iFlash->memoryDevice);
-
    hsb_generateStartScreen(mainDisplay);
    // Let start screen stay for 5 seconds
-//   vTaskDelay(INIT_START_SCREEN_DELAY);
+   vTaskDelay(INIT_START_SCREEN_DELAY);
 
+   // Construct/Load the device parameters
+   DeviceParameters_construct(&deviceParameters, &iFlash->memoryDevice);
+
+   // Construct the repair presets
+   RepairPresets_construct(&cs, &iFlash->memoryDevice);
 
    ///TODO MUST BE UPDATED
 //   hwTestItems.display           = &nhd0420->displayDevice;
@@ -245,7 +252,7 @@ static void initTask(void* parameters)
 
 
    // 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/repairMenus.c

@@ -33,6 +33,7 @@
 #include "MenuCore.h"
 #include "repairMenus.h"
 #include "repairMenu.h"
+#include "Warning.h"
 
 #include "platform.h"
 #include "Logger.h"
@@ -67,6 +68,7 @@ struct RepairMenu* const mainMenu      = &_mainMenu;
 // -----------------------------------------------------------------------------
 
 static ErrorStatus repairMenus_errorReceive(const void* const data);
+static ErrorStatus repairMenus_warningReceive(const void* const data);
 static ErrorStatus repairMenus_freeMainMenuRepairScreenUpdateSemaphore(const void* const data);
 
 // -----------------------------------------------------------------------------
@@ -91,6 +93,11 @@ ErrorStatus repairMenus_construct(void)
       returnValue = Observable_addObserver(Error_getObservable(), repairMenus_errorReceive);
    }
 
+   if (returnValue == SUCCESS)
+      {
+         returnValue = Observable_addObserver(Warning_getObservable(), repairMenus_warningReceive);
+      }
+
    return returnValue;
 }
 
@@ -110,20 +117,56 @@ struct RepairMenu* repairMenus_getMainRepairMenu(void)
 
 static ErrorStatus repairMenus_errorReceive(const void* const data)
 {
-
    T_ErrorCode errorCode = (T_ErrorCode)data;
-   // Only respond to the errors necessary
-   if (errorCode == INTERLOCK_COMMON_FAIL)
-   {
-      repairMenu_interlockFailed(mainMenu, COMMON_INTERLOCK);
-   }
-   else if (errorCode == POWERENABLE_FAIL)
-   {
 
-   }
+   switch (errorCode)
-   else if (errorCode == REPAIR_FAIL)
    {
-      repairMenu_processFailed(mainMenu);
+      case INTERLOCK_COMMON_FAIL:
+      {
+         repairMenu_interlockFailed(mainMenu, COMMON_INTERLOCK);
+         break;
+      }
+      case POWERENABLE_FAIL:
+      {
+         break;
+      }
+      case REPAIR_FAIL:
+      {
+         repairMenu_processFailed(mainMenu);
+         break;
+      }
+      case ERROR_CRC_PIN:
+      case ERROR_CRC_PARAMETERS:
+      case ERROR_CRC_PRESETS:
+      {
+         repairMenu_printCRCFailure(mainMenu, errorCode);
+         break;
+      }
+      default:
+      {
+
+      }
+   }
+   return SUCCESS;
+}
+
+
+static ErrorStatus repairMenus_warningReceive(const void* const data)
+{
+   T_WarningCode warningCode = (T_WarningCode)data;
+
+   switch (warningCode)
+   {
+      case WARNING_INTERLOCK_COMMON_FAIL:
+      {
+         repairMenu_interlockWarning(mainMenu, COMMON_INTERLOCK);
+         break;
+      }
+
+      default:
+      {
+
+      }
    }
    return SUCCESS;
 }

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

@@ -185,6 +185,12 @@ uint32_t repairProcess_getRemainingRepairTime(const struct RepairProcess* self)
 }
 
 
+uint32_t repairProcess_getTotalRepairtime(const struct RepairProcess* self)
+{
+   return SignalProfileGenerator_getTotalRepairTime(&self->signalProfileGenerator);
+}
+
+
 const struct RepairProcessRow* repairProcess_getRowInformation(const struct RepairProcess* self, int rowIndex)
 {
    return &self->row[rowIndex];
@@ -223,12 +229,12 @@ static void repairProcess_task(void* parameters)
 
    while(self->runTask)
    {
-      LOGGER_DEBUG(mainLog, "----------------------------------------");
+//      LOGGER_DEBUG(mainLog, "----------------------------------------");
       xSemaphoreTake(self->secondsSyncronisation, portMAX_DELAY);
 
       // The signal profile is identical for all rows in the regulation process
       SignalProfileGenerator_calculate(&self->signalProfileGenerator);
-      LOGGER_DEBUG(mainLog, "Signal: %d, TimeToRemain %d", self->signalProfileGenerator.signal, (unsigned int)SignalProfileGenerator_getRemainingTime(&self->signalProfileGenerator));
+//      LOGGER_DEBUG(mainLog, "Signal: %d, TimeToRemain %d", self->signalProfileGenerator.signal, (unsigned int)SignalProfileGenerator_getRemainingTime(&self->signalProfileGenerator));
 
       // Check for correct signal
       if (!SignalProfileGenerator_isPaused(&self->signalProfileGenerator))
@@ -272,7 +278,7 @@ static void repairProcess_task(void* parameters)
                // Send the PID value to the DAC
                DAConverter_setOutputVoltage(self->row[loopCounter].dacChannel, self->row[loopCounter].lastDACValue);
 
-               LOGGER_DEBUG(mainLog, "Row %d   ---   ADC: %d   Error: %d   PID: %d", loopCounter, self->row[loopCounter].lastADCValue, self->row[loopCounter].pidError, self->row[loopCounter].lastDACValue);
+//               LOGGER_DEBUG(mainLog, "Row %d   ---   ADC: %d   Error: %d   PID: %d", loopCounter, self->row[loopCounter].lastADCValue, self->row[loopCounter].pidError, self->row[loopCounter].lastDACValue);
             }
             else
             {

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

@@ -79,10 +79,7 @@ ErrorStatus repairProcesses_startMainRepairProcess(const struct RepairPreset* re
 
 void repairProcesses_abortMainRepairProcess(void)
 {
-   Interlock_setEXTI(interlock, DISABLE);
+   hsb_disableSafety();
-
-   // DISABLE external power
-   Power6V5Supply_off();
 
    repairProcess_destruct(&mainRepairProcess);
    Observable_deleteObserver(RTC_getObservable(rtc), repairProcesses_feedMainRepairProcessSecondsCounter);