diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/Makefile b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/Makefile index bc5f885..37f991e 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/Makefile +++ b/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 \ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/DACDevice.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/DACDevice.h index 801a89a..eba375a 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/DACDevice.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/MAX5715.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/MAX5715.h index 5041615..c2c9402 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/MAX5715.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/crc32.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/crc32.h index 2c2d904..927e973 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/inc/crc32.h +++ b/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. diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/CachedStorage.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/CachedStorage.c index d9a2655..85a783e 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/CachedStorage.c +++ b/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 + #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"); } } } diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/DACDevice.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/DACDevice.c index dae6d7d..b8ce811 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/DACDevice.c +++ b/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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/Logger.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/Logger.c index a346cd0..edc3d96 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/Logger.c +++ b/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 diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/MAX5715.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/MAX5715.c index d69b041..c364857 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/MAX5715.c +++ b/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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/crc32.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/crc32.c index e6dde4e..62ae9eb 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/crc32.c +++ b/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 +}; // ----------------------------------------------------------------------------- diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Makefile b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Makefile index 14a2027..e1b00e0 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Makefile +++ b/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 diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/Makefile b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/Makefile index 5c1bac3..9e13a9f 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/Makefile +++ b/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 \ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/keypadMatrix.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/keypadMatrix.c index 2532a3a..9d76313 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/keypadMatrix.c +++ b/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; -// rxQueueItem.columnCoordinate = 2; +// // SELECT PRESET 7 +// rxQueueItem.rowCoordinate = 2; +// rxQueueItem.columnCoordinate = 0; // rxQueueItem.keyEvent = PRESSED; // // Put event in queue // xQueueSend(self->rxQueue, &rxQueueItem, 0); -// rxQueueItem.rowCoordinate = 1; -// rxQueueItem.columnCoordinate = 2; +// rxQueueItem.rowCoordinate = 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; diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile index b5af792..3fb849c 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile +++ b/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 diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/ADConverter.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/ADConverter.h index 18f0f8e..e2c3355 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/ADConverter.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/DAConverter.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/DAConverter.h index e22ff52..07351fe 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/DAConverter.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/DeviceParameters.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/DeviceParameters.h index 6e3f581..dc4b46c 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/DeviceParameters.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Error.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Error.h index f76e9d1..4feaf38 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Error.h +++ b/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; // ----------------------------------------------------------------------------- diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h index ec99718..4bb1691 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h +++ b/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 warningMessage[MENUCORE_DISPLAY_ROW_LENGTH]; + char errorMessage[MENUCORE_DISPLAY_ROW_LENGTH + 1]; + 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; diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuStates.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuStates.h index 6238e42..e852c49 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuStates.h +++ b/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, diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h index a59c74d..38d2ed1 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h +++ b/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] = { diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIDParameters.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIDParameters.h index 7084a5a..9b11a67 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIDParameters.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIN.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIN.h index 9556a91..14ed3c1 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIN.h +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/PIN.h @@ -31,25 +31,93 @@ // Include files // ----------------------------------------------------------------------------- +#include + +#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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h index cfbea7a..1ee7b2e 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Voltage.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Voltage.h new file mode 100644 index 0000000..2a31c73 --- /dev/null +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Warning.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Warning.h index 606ed8b..26fb3fb 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Warning.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/hsb-mrts.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/hsb-mrts.h index 81c02e1..b81d113 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/hsb-mrts.h +++ b/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_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h index b95a66e..522b695 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h +++ b/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); diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairProcess.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairProcess.h index b85b09f..9cac3e9 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairProcess.h +++ b/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. diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/ADConverter.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/ADConverter.c index 85143d1..1aabc1f 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/ADConverter.c +++ b/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 = (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; + returnValue = ADCDevice_read(self->adcDevice); } return returnValue; } + diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c index a27c78a..69bbf44 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c @@ -25,9 +25,8 @@ // Include files // ----------------------------------------------------------------------------- -#include - #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); - int tempValue = (voltage - self->minVoltage) * maxDacValue; - tempValue /= (self->maxVoltage - self->minVoltage); - dacValue = abs(tempValue); - if (dacValue > maxDacValue) - { - dacValue = maxDacValue; - } + returnValue = Voltage_calculateVoltage(DACDevice_getCurrentValue(self->dacDevice), self->dacDevice->resolutionInBits, self->minVoltage, self->maxVoltage); } - else - { - dacValue = 0; - } - return dacValue; + return returnValue; } + + + diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DeviceParameters.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DeviceParameters.c index 3a98662..c58fa9b 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DeviceParameters.c +++ b/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}; -struct DeviceParameters* const self = &_self; +static struct DeviceParameters _dParam = {.initialized = false}; +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) -{ - -} - - -struct PIN* DeviceParameters_getPIN(void) +static void DeviceParameters_verifyCRCs(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(); + } } diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Displays.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Displays.c index fc9760f..9303473 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Displays.c +++ b/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; } + + diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c index fdc857a..9e1e409 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c @@ -25,6 +25,8 @@ // Include files // ----------------------------------------------------------------------------- +#include + #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"); - - // Determine the number of digits currently used - int divider = self->insertValue; - int numberOfDigits = 0; - while (divider != 0) - { - divider /= 10; - numberOfDigits++; - } - + int numberOfDigits = strlen(self->insertString); // 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 - // Copare with decimal ASCII - 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); - } + // Attach latest character to string + strncat(self->insertString, &keyAction.key, 1); } - 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; - LOGGER_INFO(mainLog, "Inserted Value is: %d", self->insertValue); + int numberOfDigits = strlen(self->insertString); + self->insertString[numberOfDigits - 1] = '\0'; break; } case DIGIT_INSERT_CONFIRM: { - LOGGER_INFO(mainLog, "Digit insert confirmed"); if (keyAction.actionPointer != NULL) { keyAction.actionPointer(self); diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/PIDParameters.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/PIDParameters.c new file mode 100644 index 0000000..9f18132 --- /dev/null +++ b/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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/PIN.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/PIN.c new file mode 100644 index 0000000..59dc514 --- /dev/null +++ b/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 +#include + +#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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPreset.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPreset.c index 340f772..6f3c838 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPreset.c +++ b/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; diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPresets.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPresets.c index 81e061a..4496da7 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPresets.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPresets.c @@ -28,6 +28,7 @@ #include #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; } diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c index 9fbbdb6..7e18ae4 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c +++ b/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->currentState = SPG_PREPARE; - self->initialized = true; - self->repairPreset = preset; + self->secondsCounter = 0; + self->currentPresetIndex = 0; + self->currentState = SPG_PREPARE; + 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); - - // If first preset, start voltage is 0 + // 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 (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++; diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Voltage.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Voltage.c new file mode 100644 index 0000000..6d455f7 --- /dev/null +++ b/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 + +#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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Warning.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Warning.c new file mode 100644 index 0000000..2f706c7 --- /dev/null +++ b/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); + } +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/hsb-mrts.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/hsb-mrts.c index d11e438..8c7439d 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/hsb-mrts.c +++ b/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 (1) + if (Interlock_isClosed(interlock)) { // 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"); - Display_write(mainDisplay, buffer, 3, 7); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "POWER DOWN"); + 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(); - - // 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)) + if (PCBA_getInstance()->pcba != PCBA_Tesla) { - adcR1Value = ADConverter_getInputVoltage(adcRow1); - adcR2Value = ADConverter_getInputVoltage(adcRow2); - adcR3Value = ADConverter_getInputVoltage(adcRow3); - vTaskDelay(100); + // 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); + 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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c index daae206..99a6f33 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c +++ b/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 HwValidationMenuItems hwTestItems; - -struct HwValidationMenu* hwValidation = &_hwValidation; +//static struct HwValidationMenu _hwValidation = {.initialized = false}; +//static struct HwValidationMenuItems hwTestItems; +//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); diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c index 26efe21..03ec113 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c @@ -25,8 +25,12 @@ // Include files // ----------------------------------------------------------------------------- -#include "stdio.h" -#include "string.h" +#include +#include +#include + +#include "DeviceParameters.h" +#include "PIDParameters.h" #include "repairMenu.h" #include "repairMenus.h" #include "RepairPreset.h" @@ -48,6 +52,7 @@ #include "Interlock.h" #include "internalADC.h" #include "MAX5715.h" +#include "Power6V5Supply.h" #include "TeslaGunSafety.h" #include "KeyboardDevice.h" @@ -63,7 +68,7 @@ #define MENU_HAS_CURSOR (true) #define MENU_HAS_NO_CURSOR (false) -#define REPAIRMENU_POPUPSCREEN_TIME (3) +#define REPAIRMENU_POPUPSCREEN_TIME_MS (1000) // ----------------------------------------------------------------------------- // Type definitions @@ -81,6 +86,9 @@ // Function declarations // ----------------------------------------------------------------------------- +static void repairMenu_clearInsertString(struct MenuCore* self); +static void repairMenu_fillInsertStringWithValue(struct MenuCore* self, int value); +static int repairMenu_getValueFromInsertString(struct MenuCore* self); static void repairMenu_printError(struct MenuCore* self); static void repairMenu_printWarning(struct MenuCore* self); static void repairMenu_printRepair(struct MenuCore* self); @@ -91,7 +99,21 @@ static void repairMenu_printPreset(struct MenuCore* self); static void repairMenu_printChangePinScreen(struct MenuCore* self); static void repairMenu_printIOInterlockStatus(struct MenuCore* self); +static void repairMenu_prepareAdminPinVerification(struct MenuCore* self); +static void repairMenu_confirmAdminPin(struct MenuCore* self); +static void repairMenu_configPinChange(struct MenuCore* self); +static void repairMenu_configConfirmFirstPin(struct MenuCore* self); +static void repairMenu_configConfirmSecondPin(struct MenuCore* self); static void repairMenu_configPresetFirstSoftstart(struct MenuCore* self); +static void repairMenu_configVoltageOutput(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutFirstRow(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutFirstRowGotoNext(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutSecondRow(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutSecondRowGotoPrevious(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutSecondRowGotoNext(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutThirdRow(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutThirdRowGotoPrevious(struct MenuCore* self); +static void repairMenu_configConfirmVoltageOutThirdRowGotoPrevious(struct MenuCore* self); static void repairMenu_configConfirmPresetFirstSoftstart(struct MenuCore* self); static void repairMenu_configConfirmPresetFirstDuration(struct MenuCore* self); static void repairMenu_configConfirmPresetFirstVoltage(struct MenuCore* self); @@ -99,9 +121,16 @@ static void repairMenu_configConfirmPresetSecondSoftstart(struct MenuCore* self) static void repairMenu_configConfirmPresetSecondDuration(struct MenuCore* self); static void repairMenu_configConfirmPresetSecondVoltage(struct MenuCore* self); static void repairMenu_configConfirmPreset(struct MenuCore* self); +static void repairMenu_configPID(struct MenuCore* self); +static void repairMenu_configConfirmPIDKp(struct MenuCore* self); +static void repairMenu_configConfirmPIDKi(struct MenuCore* self); +static void repairMenu_configConfirmPIDKd(struct MenuCore* self); static void repairMenu_printConfigPreset(struct MenuCore* self); - +static void repairMenu_printPINVerification(struct MenuCore* self); +static void repairMenu_printVoltageOutput(struct MenuCore* self); +static void repairMenu_printPIDConstants(struct MenuCore* self); static void repairMenu_printInfo(struct MenuCore* self); +static void repairMenu_confirmCalibrationPin(struct MenuCore* self); static void repairMenu_selectCathodeRepair(struct MenuCore* self); static void repairMenu_selectMCPRepair(struct MenuCore* self); @@ -115,6 +144,7 @@ static void repairMenu_stopRepairProcess(struct MenuCore* self); static void repairMenu_abortRepairProcessAndGotoMainMenu(struct MenuCore* self); static void repairMenu_pauseRepairProcess(struct MenuCore* self); static void repairMenu_continueRepairProcess(struct MenuCore* self); +static void repairMenu_gotoLastState(struct MenuCore* self); // ----------------------------------------------------------------------------- @@ -194,6 +224,18 @@ void repairMenu_destruct (struct RepairMenu* self) } +void repairMenu_interlockWarning(struct RepairMenu* self, T_INTERLOCK_ID interlockID) +{ + self->menuCore->lastMenuState = RM_REPAIR_PAUSE; + MenuCore_changeState(self->menuCore, RM_WARNING_STATE); + + if (interlockID == COMMON_INTERLOCK) + { + snprintf(self->menuCore->warningMessage, sizeof(self->menuCore->warningMessage) / sizeof(self->menuCore->warningMessage[0]), "COVER OPEN"); + } +} + + void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID interlockID) { MenuCore_changeState(self->menuCore, RM_ERROR_STATE); @@ -212,21 +254,59 @@ void repairMenu_processFailed(struct RepairMenu* self) } +void repairMenu_printCRCFailure(struct RepairMenu* self, T_ErrorCode errorCode) +{ + while (self->menuCore->menuState == RM_ERROR_STATE) + { + vTaskDelay(100); + } + + MenuCore_changeState(self->menuCore, RM_ERROR_STATE); + if (errorCode == ERROR_CRC_PIN) + { + snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PIN CRC ERROR"); + } + else if (errorCode == ERROR_CRC_PARAMETERS) + { + snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PARAMETERS CRC ERROR"); + } + else if (errorCode == ERROR_CRC_PRESETS) + { + snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PRESETS CRC ERROR"); + } +} + +static void repairMenu_clearInsertString(struct MenuCore* self) +{ + self->insertString[0] = '\0'; +} +static void repairMenu_fillInsertStringWithValue(struct MenuCore* self, int value) +{ + snprintf(self->insertString, sizeof(self->insertString) / sizeof(self->insertString[0]), "%d", value); +} +static int repairMenu_getValueFromInsertString(struct MenuCore* self) +{ + return atoi(self->insertString); +} + static void repairMenu_printError(struct MenuCore* self) { - Display_write(self->display, "!!ERROR!!", 2, 6); - Display_write(self->display, self->errorMessage, 3, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->errorMessage)) / 2)); + Display_write(self->display, "!!ERROR!!", 1, 6); + Display_write(self->display, self->errorMessage, 2, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->errorMessage)) / 2)); + Display_write(self->display, "Hit X to continue", 4, 2); } static void repairMenu_printWarning(struct MenuCore* self) { - + Display_write(self->display, "!!WARNING!!", 1, 5); + Display_write(self->display, self->warningMessage, 2, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->warningMessage)) / 2)); + Display_write(self->display, "Hit X to continue", 4, 2); } @@ -245,15 +325,19 @@ static void repairMenu_printRepair(struct MenuCore* self) } else { - struct Time remainingTime; - RTC_calculateTimeFromSeconds(repairProcess_getRemainingRepairTime(repairProcess), &remainingTime); - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%1d", repairMenu->repairPreset->presetNumber); Display_write(self->display, buffer, 1, 1); - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d remain ", remainingTime.hours, remainingTime.minutes, remainingTime.seconds); + struct Time totalTime; + RTC_calculateTimeFromSeconds(repairProcess_getTotalRepairtime(repairProcess), &totalTime); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d total", totalTime.hours, totalTime.minutes, totalTime.seconds); Display_write(self->display, buffer, 1, 4); + struct Time remainingTime; + RTC_calculateTimeFromSeconds(repairProcess_getRemainingRepairTime(repairProcess), &remainingTime); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d remain", remainingTime.hours, remainingTime.minutes, remainingTime.seconds); + Display_write(self->display, buffer, 2, 4); + // Regulation is unique for each row // For TESLA repair only row 1 (out of 0,1,2) is used // For ANODE and Cathode/MCP, all 3 rows are used @@ -263,21 +347,16 @@ static void repairMenu_printRepair(struct MenuCore* self) row = repairProcess_getRowInformation(repairProcess, loopCounter); snprintf (buffer, sizeof(buffer) / sizeof(buffer[0]), "R%d", loopCounter + 1); - Display_write(self->display, buffer, 2, ((loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) + loopCounter) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer))); + Display_write(self->display, buffer, 3, ((loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) + loopCounter) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer))); if (!row->errorData.rowHasError) { snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", row->lastADCValue); - Display_write(self->display, buffer, 3, (loopCounter + (loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS)) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer))); - - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%4dER", row->pidError); Display_write(self->display, buffer, 4, (loopCounter + (loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS)) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer))); + } else { - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " ROW "); - Display_write(self->display, buffer, 3, (loopCounter + (loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS)) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer))); - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "ERROR "); Display_write(self->display, buffer, 4, (loopCounter + (loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS)) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer))); } @@ -309,7 +388,7 @@ static void repairMenu_printPause(struct MenuCore* self) static void repairMenu_printFinish(struct MenuCore* self) { - Display_write(self->display, "REPAIR FINISHED", 2, 6); + Display_write(self->display, "REPAIR FINISHED", 2, 3); Display_write(self->display, "Hit ENT to continue", 4, 2); } @@ -346,18 +425,49 @@ static void repairMenu_printPreset(struct MenuCore* self) } +static void repairMenu_prepareAdminPinVerification(struct MenuCore* self) +{ + // RESET the insert string before inserting the PIN + self->insertString[0] = '\0'; +} + + + static void repairMenu_printChangePinScreen(struct MenuCore* self) { char buffer[self->display->displayDevice->parameters.numberOfColumns]; - - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " New PIN: ----"); + char pin[PIN_NUMBER_OF_DIGITS + 1]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " New PIN:"); Display_write(self->display, buffer, 3, 1); - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " Repeat PIN: ----"); - Display_write(self->display, buffer, 4, 1); - Display_setCursorToPosition(self->display, 3, 14); - DisplayDevice_setBlinkingCursorState(self->display->displayDevice, ON); + int numberOfDigits = strlen(self->insertString); + int loopcounter; + for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++) + { + if (loopcounter < numberOfDigits) + { + pin[loopcounter] = '*'; + } + else + { + pin[loopcounter] = '-'; + } + } + pin[PIN_NUMBER_OF_DIGITS] = '\0'; + + + if (self->menuState == RM_ADMIN_CHANGEPIN_FIRST_INSERT) + { + Display_write(self->display, pin, 3, 14); + } + else if (self->menuState == RM_ADMIN_CHANGEPIN_SECOND_INSERT) + { + Display_write(self->display, "****", 3, 14); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " Repeat PIN:"); + Display_write(self->display, buffer, 4, 1); + Display_write(self->display, pin, 4, 14); + } } @@ -367,7 +477,7 @@ static void repairMenu_printIOInterlockStatus(struct MenuCore* self) char buffer[self->display->displayDevice->parameters.numberOfColumns]; snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Cover Interlock is"); - Display_write(self->display, buffer, 2, 1); + Display_write(self->display, buffer, 2, 2); if (Interlock_isClosed(interlock)) { @@ -376,51 +486,210 @@ static void repairMenu_printIOInterlockStatus(struct MenuCore* self) } else { - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "open"); - Display_write(self->display, buffer, 3, 9); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " open "); + Display_write(self->display, buffer, 3, 8); } } +static void repairMenu_confirmAdminPin(struct MenuCore* self) +{ + char buffer[20]; + char pin[PIN_NUMBER_OF_DIGITS]; + + int loopcounter; + for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++) + { + pin[loopcounter] = self->insertString[loopcounter] - 48; + } + + if (PIN_isOK(DeviceParameters_getPIN(), pin)) + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN OK"); + Display_clearScreen(self->display); + Display_write(self->display, buffer, 3, 8); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); + MenuCore_changeState(self, RM_ADMINMENU); + } + else + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN DENIED"); + Display_clearScreen(self->display); + Display_write(self->display, buffer, 3, 6); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); + MenuCore_changeState(self, RM_MAINMENU); + } +} + + +static void repairMenu_configPinChange(struct MenuCore* self) +{ + repairMenu_clearInsertString(self); +} + + +static void repairMenu_configConfirmFirstPin(struct MenuCore* self) +{ + char pin[PIN_NUMBER_OF_DIGITS]; + + int loopcounter; + for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++) + { + pin[loopcounter] = self->insertString[loopcounter] - 48; + } + PIN_changePinFirstInsert(DeviceParameters_getPIN(), pin); + repairMenu_clearInsertString(self); + MenuCore_changeState(self, RM_ADMIN_CHANGEPIN_SECOND_INSERT); +} + +static void repairMenu_configConfirmSecondPin(struct MenuCore* self) +{ + char pin[PIN_NUMBER_OF_DIGITS]; + + int loopcounter; + for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++) + { + pin[loopcounter] = self->insertString[loopcounter] - 48; + } + char buffer[20]; + if (PIN_changePinSecondInsert(DeviceParameters_getPIN(), pin) == SUCCESS) + { + DeviceParameters_writePIN(DeviceParameters_getPIN()); + DeviceParameters_saveParameters(); + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "New PIN accepted"); + Display_clearScreen(self->display); + Display_write(self->display, buffer, 3, 3); + } + else + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "New PIN denied"); + Display_clearScreen(self->display); + Display_write(self->display, buffer, 3, 4); + } + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); + MenuCore_changeState(self, RM_ADMINMENU); +} + + static void repairMenu_configPresetFirstSoftstart(struct MenuCore* self) { - self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[0].softstartDuration / 60; + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[0].softstartDuration / 60); +} + + +static void repairMenu_configVoltageOutput(struct MenuCore* self) +{ + Power6V5Supply_on(); + repairMenu_clearInsertString(self); + // In case of CathodeMCP, the insert value must be negative + repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow1)); +} + +static void repairMenu_configConfirmVoltageOutFirstRow(struct MenuCore* self) +{ + DAConverter_setOutputVoltage(dacRow1, repairMenu_getValueFromInsertString(self)); +} + +static void repairMenu_configConfirmVoltageOutFirstRowGotoNext(struct MenuCore* self) +{ + // Takeover the inserted value + repairMenu_configConfirmVoltageOutFirstRow(self); + // Goto next insertion state + MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2); + // Receive next value for insertion + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow2)); +} + +static void repairMenu_configConfirmVoltageOutSecondRow(struct MenuCore* self) +{ + DAConverter_setOutputVoltage(dacRow2, repairMenu_getValueFromInsertString(self)); +} + +static void repairMenu_configConfirmVoltageOutSecondRowGotoPrevious(struct MenuCore* self) +{ + // Takeover the inserted value + repairMenu_configConfirmVoltageOutSecondRow(self); + // Goto next insertion state + MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1); + // Receive next value for insertion + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow1)); +} + +static void repairMenu_configConfirmVoltageOutSecondRowGotoNext(struct MenuCore* self) +{ + // Takeover the inserted value + repairMenu_configConfirmVoltageOutSecondRow(self); + // Goto next insertion state + MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3); + // Receive next value for insertion + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow3)); +} + +static void repairMenu_configConfirmVoltageOutThirdRow(struct MenuCore* self) +{ + DAConverter_setOutputVoltage(dacRow3, repairMenu_getValueFromInsertString(self)); +} + +static void repairMenu_configConfirmVoltageOutThirdRowGotoPrevious(struct MenuCore* self) +{ + // Takeover the inserted value + repairMenu_configConfirmVoltageOutThirdRow(self); + // Goto next insertion state + MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2); + // Receive next value for insertion + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow2)); } static void repairMenu_configConfirmPresetFirstSoftstart(struct MenuCore* self) { // Takeover the inserted value - RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], self->insertValue * 60); + RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self) * 60); // Goto next insertion state MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_FIRST_DURATION); // Receive next value for insertion - self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[0].duration / 60; + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[0].duration / 60); } static void repairMenu_configConfirmPresetFirstDuration(struct MenuCore* self) { // Takeover the inserted value - RepairPreset_setDurationValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], self->insertValue * 60); + RepairPreset_setDurationValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self) * 60); // Goto next insertion state MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE); // Receive next value for insertion - self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[0].voltage; + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, abs(RepairPresets_getPreset(self->selectionIndex)->preset[0].voltage)); } static void repairMenu_configConfirmPresetFirstVoltage(struct MenuCore* self) { // Takeover the inserted value - RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], self->insertValue); + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self)); + } + else + { + RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self)); + } // Check if another Stage is available inside this preset if (RepairPresets_getPreset(self->selectionIndex)->numberOfStages > 1) { // There is another stage // Receive next value for insertion - self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[1].softstartDuration / 60; + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[1].softstartDuration / 60); MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART); } else @@ -435,29 +704,31 @@ static void repairMenu_configConfirmPresetFirstVoltage(struct MenuCore* self) static void repairMenu_configConfirmPresetSecondSoftstart(struct MenuCore* self) { // Takeover the inserted value - RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], self->insertValue * 60); + RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], repairMenu_getValueFromInsertString(self) * 60); // Goto next insertion state MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_DURATION); // Receive next value for insertion - self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[1].duration / 60; + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[1].duration / 60); } static void repairMenu_configConfirmPresetSecondDuration(struct MenuCore* self) { // Takeover the inserted value - RepairPreset_setDurationValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], self->insertValue * 60); + RepairPreset_setDurationValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], repairMenu_getValueFromInsertString(self) * 60); // Goto next insertion state MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE); // Receive next value for insertion - self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[1].voltage; + repairMenu_clearInsertString(self); + repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[1].voltage); } static void repairMenu_configConfirmPresetSecondVoltage(struct MenuCore* self) { // Takeover the inserted value - RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], self->insertValue); + RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], repairMenu_getValueFromInsertString(self)); // Goto next insertion state // Check if another Stage is available inside this preset @@ -485,17 +756,80 @@ static void repairMenu_configConfirmPreset(struct MenuCore* self) Display_clearScreen(self->display); char buffer[20]; snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d saved", self->selectionIndex); - Display_write(self->display, buffer, 3, 2); - vTaskDelay(2000); + Display_write(self->display, buffer, 3, 4); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); } +static void repairMenu_configPID(struct MenuCore* self) +{ + + repairMenu_fillInsertStringWithValue(self, DeviceParameters_getPIDParameters()->Kp); +} + + +static void repairMenu_configConfirmPIDKp(struct MenuCore* self) +{ + PIDParameters_setKp(DeviceParameters_getPIDParameters(), repairMenu_getValueFromInsertString(self)); + // Goto next insertion state + MenuCore_changeState(self, RM_ADMIN_PID_CONFIG_KI); + // Receive next value for insertion + repairMenu_fillInsertStringWithValue(self, DeviceParameters_getPIDParameters()->Ki); + +} + + +static void repairMenu_configConfirmPIDKi(struct MenuCore* self) +{ + PIDParameters_setKi(DeviceParameters_getPIDParameters(), repairMenu_getValueFromInsertString(self)); + // Goto next insertion state + MenuCore_changeState(self, RM_ADMIN_PID_CONFIG_KD); + // Receive next value for insertion + repairMenu_fillInsertStringWithValue(self, DeviceParameters_getPIDParameters()->Kd); + +} + + +static void repairMenu_configConfirmPIDKd(struct MenuCore* self) +{ + PIDParameters_setKd(DeviceParameters_getPIDParameters(), repairMenu_getValueFromInsertString(self)); + // Write inserted values to FLASH + DeviceParameters_writePIDParameters(DeviceParameters_getPIDParameters()); + DeviceParameters_saveParameters(); + + // Go back next admin menu + MenuCore_changeState(self, RM_ADMINMENU); + + Display_clearScreen(self->display); + char buffer[20]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Constants saved"); + Display_write(self->display, buffer, 3, 3); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); +} + + +static void repairMenu_printAdminVoltageInput(struct MenuCore* self) +{ + char buffer[self->display->displayDevice->parameters.numberOfColumns + 1]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Voltage input"); + Display_write(self->display, buffer, 1, 1); + + if (PCBA_getInstance()->pcba != PCBA_Tesla) + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Row1: %5dV | %4Xx", ADConverter_getInputVoltage(adcRow1), ADConverter_getInputConverterValue(adcRow1)); + Display_write(self->display, buffer, 2, 1); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Row3: %5dV | %4Xx", ADConverter_getInputVoltage(adcRow3), ADConverter_getInputConverterValue(adcRow3)); + Display_write(self->display, buffer, 4, 1); + } + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Row2: %5dV | %4Xx", ADConverter_getInputVoltage(adcRow2), ADConverter_getInputConverterValue(adcRow2)); + Display_write(self->display, buffer, 3, 1); +} + static void repairMenu_printConfigPreset(struct MenuCore* self) { int loopCounter; char buffer[self->display->displayDevice->parameters.numberOfColumns]; - // Print the preset information of the current preset under the cursor, NOT the preset that is currently selected snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->selectionIndex); // Always print Row1 (index0), ignoring the scrolling index Display_write(self->display, buffer, 1, 1); @@ -518,7 +852,67 @@ static void repairMenu_printConfigPreset(struct MenuCore* self) snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].voltage); Display_write(self->display, buffer, 4, 8 + loopCounter * 7); } +} + +static void repairMenu_printPINVerification(struct MenuCore* self) +{ + char buffer[self->display->displayDevice->parameters.numberOfColumns]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Insert PIN"); + Display_write(self->display, buffer, 3, 6); + + int numberOfDigits = strlen(self->insertString); + int loopcounter; + for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++) + { + if (loopcounter < numberOfDigits) + { + buffer[loopcounter] = '*'; + } + else + { + buffer[loopcounter] = '-'; + } + } + buffer[PIN_NUMBER_OF_DIGITS] = '\0'; + + Display_write(self->display, buffer, 4, 9); + +} + + +static void repairMenu_printVoltageOutput(struct MenuCore* self) +{ + char buffer[self->display->displayDevice->parameters.numberOfColumns]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Set voltage out"); + // Always print Row1 (index0), ignoring the scrolling index + Display_write(self->display, buffer, 1, 1); + + if (PCBA_getInstance()->pcba != PCBA_Tesla) + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "R1: %5dV | %5dV", (unsigned int)DAConverter_getCurrentValue(dacRow1), ADConverter_getInputVoltage(adcRow1)); + Display_write(self->display, buffer, 2, 1); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "R3: %5dV | %5dV", (unsigned int)DAConverter_getCurrentValue(dacRow3), ADConverter_getInputVoltage(adcRow3)); + Display_write(self->display, buffer, 4, 1); + } + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "R2: %5dV | %5dV", (unsigned int)DAConverter_getCurrentValue(dacRow2), ADConverter_getInputVoltage(adcRow2)); + Display_write(self->display, buffer, 3, 1); +} + + +static void repairMenu_printPIDConstants(struct MenuCore* self) +{ + char buffer[self->display->displayDevice->parameters.numberOfColumns]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PID constants"); + // Always print Row1 (index0), ignoring the scrolling index + Display_write(self->display, buffer, 1, 1); + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Kp: %5d", DeviceParameters_getPIDParameters()->Kp); + Display_write(self->display, buffer, 2, 1); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Ki: %5d", DeviceParameters_getPIDParameters()->Ki); + Display_write(self->display, buffer, 3, 1); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Kd: %5d", DeviceParameters_getPIDParameters()->Kd); + Display_write(self->display, buffer, 4, 1); } @@ -535,6 +929,42 @@ static void repairMenu_printInfo(struct MenuCore* self) } +static void repairMenu_confirmCalibrationPin(struct MenuCore* self) +{ + char buffer[20]; + char pin[PIN_NUMBER_OF_DIGITS]; + + int loopcounter; + for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++) + { + pin[loopcounter] = self->insertString[loopcounter] - 48; + } + + if (PIN_isOK(DeviceParameters_getPIN(), pin)) + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN OK"); + Display_clearScreen(self->display); + Display_write(self->display, buffer, 3, 8); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + MenuCore_changeState(self, RM_CALIBRATIONMENU); + } + else + { + MenuCore_changeState(self, RM_CALIBRATIONMENU); + } + } + else + { + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN DENIED"); + Display_clearScreen(self->display); + Display_write(self->display, buffer, 3, 6); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); + MenuCore_changeState(self, RM_MAINMENU); + } +} + static void repairMenu_selectCathodeRepair(struct MenuCore* self) { @@ -563,7 +993,7 @@ static void repairMenu_selectPreset(struct MenuCore* self) char buffer[20]; snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", self->selectionIndex); Display_write(self->display, buffer, 3, 2); - vTaskDelay(2000); + vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS); } @@ -606,16 +1036,7 @@ static void repairMenu_startRepairProcess(struct MenuCore* self) if (returnValue == SUCCESS) { // Enable all safety features of the HSB setup - returnValue = hsb_enableSafety(); - } - - if (returnValue == SUCCESS) - { - // In case of a TESLA repair, release the teslaGunSafety - if (PCBA_getInstance()->pcba == PCBA_Tesla) - { - TeslaGunSafety_release(); - } + returnValue = hsb_enableSafetyWithError(); } // If all is OK, start the repair process @@ -647,10 +1068,6 @@ static void repairMenu_startRepairProcess(struct MenuCore* self) static void repairMenu_stopRepairProcess(struct MenuCore* self) { - if (PCBA_getInstance()->pcba == PCBA_Tesla) - { - TeslaGunSafety_block(); - } struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu(); repairProcesses_mainRepairProcessRemoveObserver(tempMenu->observer); repairProcesses_abortMainRepairProcess(); @@ -675,11 +1092,16 @@ static void repairMenu_pauseRepairProcess(struct MenuCore* self) static void repairMenu_continueRepairProcess(struct MenuCore* self) { - hsb_enableSafety(); + hsb_enableSafetyWithWarning(); MenuCore_changeState(self, RM_REPAIR_RUNNING); repairProcess_continueProcess(repairProcesses_getMainRepairProcess()); } +static void repairMenu_gotoLastState(struct MenuCore* self) +{ + MenuCore_changeState(self, self->lastMenuState); +} + void repairMenu_menuStateHandle(struct MenuCore* self) { @@ -689,7 +1111,10 @@ void repairMenu_menuStateHandle(struct MenuCore* self) // Show ERROR message repairMenu_printError(self); // Handle error - repairMenu_stopRepairProcess(self); + if (hsb_safetyIsEnabled()) + { + repairMenu_stopRepairProcess(self); + } } else if (self->menuState == RM_WARNING_STATE) { @@ -705,9 +1130,9 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { // Check the remaining repair time uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess()); - if (remainingTime > REPAIRMENU_POPUPSCREEN_TIME) + if (remainingTime > (2 * REPAIRMENU_POPUPSCREEN_TIME_MS / 1000)) { - self->popUpCounter = remainingTime - REPAIRMENU_POPUPSCREEN_TIME; + self->popUpCounter = remainingTime - (2 * REPAIRMENU_POPUPSCREEN_TIME_MS / 1000); self->lastMenuState = self->menuState; } if (remainingTime == 0) @@ -715,6 +1140,10 @@ void repairMenu_menuStateHandle(struct MenuCore* self) // repair is finished MenuCore_changeState(self, RM_FINISH_CONTROL); } +// else if (remainingTime == 0xFFFFFFFF) +// { +// Error_postError(REPAIR_FAIL); +// } else { // Create the repair screen @@ -745,18 +1174,33 @@ void repairMenu_menuStateHandle(struct MenuCore* self) repairMenu_printFinish(self); } + else if (self->menuState == RM_ADMINMENU_PIN_VERIFICATION) + { + repairMenu_printPINVerification(self); + } + else if (self->menuState == RM_ADMIN_IO_INTERLOCK) { // Show the current INTERLOCK status repairMenu_printIOInterlockStatus(self); } + else if(self->menuState == RM_ADMIN_IO_VOLTAGE_IN) + { + repairMenu_printAdminVoltageInput(self); + } + else if (self->menuState == RM_ADMIN_INFO) { repairMenu_printInfo(self); } - else if (self->menuState == RM_ADMIN_CHANGEPIN) + else if (self->menuState == RM_ADMIN_CHANGEPIN_FIRST_INSERT) + { + repairMenu_printChangePinScreen(self); + } + + else if (self->menuState == RM_ADMIN_CHANGEPIN_SECOND_INSERT) { repairMenu_printChangePinScreen(self); } @@ -765,9 +1209,22 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { repairMenu_printConfigPreset(self); char buffer[7]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%4d", self->insertValue); - Display_write(self->display, buffer, 2, 9); + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sm", self->insertString); + Display_write(self->display, buffer, 2, 8); + vTaskDelay(2); Display_setCursorToPosition(self->display, 2, 12); + vTaskDelay(2); Display_setBlinkingCursorState(self->display, ON); } @@ -775,9 +1232,22 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { repairMenu_printConfigPreset(self); char buffer[7]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%4d", self->insertValue); - Display_write(self->display, buffer, 3, 9); + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sm", self->insertString); + Display_write(self->display, buffer, 3, 8); + vTaskDelay(2); Display_setCursorToPosition(self->display, 3, 12); + vTaskDelay(2); Display_setBlinkingCursorState(self->display, ON); } @@ -785,7 +1255,31 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { repairMenu_printConfigPreset(self); char buffer[7]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue); + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + if (atoi(self->insertString) > 0) + { + int loopcounter; + for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--) + { + self->insertString[loopcounter + 1] = self->insertString[loopcounter]; + } + self->insertString[0] = '-'; + } + } + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); + Display_write(self->display, buffer, 4, 8); Display_setCursorToPosition(self->display, 4, 12); Display_setBlinkingCursorState(self->display, ON); @@ -794,7 +1288,18 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { repairMenu_printConfigPreset(self); char buffer[7]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue); + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); Display_write(self->display, buffer, 2, 15); Display_setCursorToPosition(self->display, 2, 19); Display_setBlinkingCursorState(self->display, ON); @@ -804,7 +1309,18 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { repairMenu_printConfigPreset(self); char buffer[7]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue); + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); Display_write(self->display, buffer, 3, 15); Display_setCursorToPosition(self->display, 3, 19); Display_setBlinkingCursorState(self->display, ON); @@ -814,18 +1330,231 @@ void repairMenu_menuStateHandle(struct MenuCore* self) { repairMenu_printConfigPreset(self); char buffer[7]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue); + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + if (atoi(self->insertString) > 0) + { + LOGGER_DEBUG(mainLog, "%s", self->insertString); + int loopcounter; + for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--) + { + self->insertString[loopcounter + 1] = self->insertString[loopcounter]; + } + self->insertString[0] = '-'; + LOGGER_DEBUG(mainLog, "%s", self->insertString); + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); + Display_write(self->display, buffer, 4, 15); Display_setCursorToPosition(self->display, 4, 19); Display_setBlinkingCursorState(self->display, ON); } + + else if (self->menuState == RM_ADMIN_PID_CONFIG_KP) + { + repairMenu_printPIDConstants(self); + char buffer[7]; + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); + Display_write(self->display, buffer, 2, 5); + Display_setCursorToPosition(self->display, 2, 9); + Display_setBlinkingCursorState(self->display, ON); + } + + else if (self->menuState == RM_ADMIN_PID_CONFIG_KI) + { + repairMenu_printPIDConstants(self); + char buffer[7]; + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); + Display_write(self->display, buffer, 3, 5); + Display_setCursorToPosition(self->display, 3, 9); + Display_setBlinkingCursorState(self->display, ON); + } + + else if (self->menuState == RM_ADMIN_PID_CONFIG_KD) + { + repairMenu_printPIDConstants(self); + char buffer[7]; + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString); + Display_write(self->display, buffer, 4, 5); + Display_setCursorToPosition(self->display, 4, 9); + Display_setBlinkingCursorState(self->display, ON); + } + + else if (self->menuState == RM_CALIBRATIONMENU_PIN_VERIFICATION) + { + repairMenu_printPINVerification(self); + } + + else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1) + { + repairMenu_printVoltageOutput(self); + char buffer[7]; + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + if (atoi(self->insertString) > 0) + { + int loopcounter; + for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--) + { + self->insertString[loopcounter + 1] = self->insertString[loopcounter]; + } + self->insertString[0] = '-'; + } + } + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString); + + Display_write(self->display, buffer, 2, 5); + Display_setCursorToPosition(self->display, 2, 9); + Display_setBlinkingCursorState(self->display, ON); + } + + else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2) + { + repairMenu_printVoltageOutput(self); + char buffer[7]; + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + if (atoi(self->insertString) > 0) + { + int loopcounter; + for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--) + { + self->insertString[loopcounter + 1] = self->insertString[loopcounter]; + } + self->insertString[0] = '-'; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString); + Display_write(self->display, buffer, 3, 5); + Display_setCursorToPosition(self->display, 3, 9); + Display_setBlinkingCursorState(self->display, ON); + } + + else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3) + { + repairMenu_printVoltageOutput(self); + char buffer[7]; + + // Remove leading 0 from string if necessary + if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1)) + { + int loopcounter; + for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++) + { + self->insertString[loopcounter] = self->insertString[loopcounter + 1]; + } + } + + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + if (atoi(self->insertString) > 0) + { + int loopcounter; + for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--) + { + self->insertString[loopcounter + 1] = self->insertString[loopcounter]; + } + self->insertString[0] = '-'; + } + } + + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString); + Display_write(self->display, buffer, 4, 5); + Display_setCursorToPosition(self->display, 4, 9); + Display_setBlinkingCursorState(self->display, ON); + } + + else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP) + { + // RESET all DACs to 0 + DAConverter_setOutputVoltage(dacRow1, 0); + DAConverter_setOutputVoltage(dacRow2, 0); + DAConverter_setOutputVoltage(dacRow3, 0); + + Power6V5Supply_off(); + + char buffer[21]; + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "All rows reset to 0V"); + Display_write(self->display, buffer, 3, 1); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Press X to continue"); + Display_write(self->display, buffer, 4, 1); + } } void repairMenu_createMenuEntries(struct MenuCore* menuCore) { - + int numberOfDigits; /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- * MAIN MENU SCREEN with 3 options * TUBE REPAIR @@ -843,14 +1572,13 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) { // For Cathode/MCP PCBA, the type of repair must be selected first MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_REPAIR_CATHODEMCP_SELECT, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_CATHODEMCP_SELECT, NULL); } else { MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMINMENU, NULL); } - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][3], RM_CALIBRATIONMENU, NULL); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMINMENU_PIN_VERIFICATION, repairMenu_prepareAdminPinVerification); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][3], RM_CALIBRATIONMENU_PIN_VERIFICATION, repairMenu_prepareAdminPinVerification); MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_MAINMENU], 'U', PRESSED); MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_MAINMENU], 'D', PRESSED); MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_MAINMENU], 'E', PRESSED); @@ -961,6 +1689,27 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESET_PRINT], 'L', PRESSED, RM_PRESETMENU); + /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + * ADMIN PIN VERIFICATION + * This screen is designed in a dedicated function + * + * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + */ + numberOfDigits = PIN_NUMBER_OF_DIGITS; + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], 'E', PRESSED, repairMenu_confirmAdminPin); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], 'X', PRESSED, RM_MAINMENU); /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -972,14 +1721,14 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) */ MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3); MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][0], RM_ADMIN_CATHODEMCP_SELECT, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_ADMINMENU, repairMenu_selectCathodeRepair); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_ADMINMENU, repairMenu_selectMCPRepair); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_ADMIN_PRESET_CONFIG_SELECT, repairMenu_selectCathodeRepair); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_ADMIN_PRESET_CONFIG_SELECT, repairMenu_selectMCPRepair); MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'U', PRESSED); MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'D', PRESSED); MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'E', PRESSED); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], '1', PRESSED, 1); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], '2', PRESSED, 2); - MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'X', PRESSED, RM_MAINMENU); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'X', PRESSED, RM_ADMINMENU); /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- * ADMINISTRATION MAIN MENU @@ -990,47 +1739,65 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) * Info & Version * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- */ - MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU], MENU_HAS_CURSOR, 5); + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU], MENU_HAS_CURSOR, 6); MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][0], RM_ADMINMENU, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_CHANGEPIN, NULL); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_CHANGEPIN_FIRST_INSERT, repairMenu_configPinChange); MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_IOCONTROL, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_PRESET_CONFIG_SELECT, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_INFO, NULL); if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) { - MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_ADMIN_CATHODEMCP_SELECT); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_CATHODEMCP_SELECT, NULL); } else { - MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_MAINMENU); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_PRESET_CONFIG_SELECT, NULL); } + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_PID_CONFIG_KP, repairMenu_configPID); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][5], RM_ADMIN_INFO, NULL); MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_ADMINMENU], 'U', PRESSED); MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_ADMINMENU], 'D', PRESSED); MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_ADMINMENU], 'E', PRESSED); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_MAINMENU); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '1', PRESSED, 1); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '2', PRESSED, 2); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '3', PRESSED, 3); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '4', PRESSED, 4); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '5', PRESSED, 5); /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- * ADMIN change pin * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- */ + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], MENU_HAS_NO_CURSOR, 5); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], MenuText_ADMINCHANGEPINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_CHANGEPIN_FIRST_INSERT, NULL); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], 'X', PRESSED, RM_ADMINMENU); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '0', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '1', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '2', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '3', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '4', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '5', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '6', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '7', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '8', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '9', PRESSED, 4); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], 'E', PRESSED, repairMenu_configConfirmFirstPin); - MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], MENU_HAS_NO_CURSOR, 5); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], MenuText_ADMINCHANGEPINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_CHANGEPIN, NULL); - MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], 'X', PRESSED, RM_ADMINMENU); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '0', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '1', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '2', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '3', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '4', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '5', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '6', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '7', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '8', PRESSED, 4); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '9', PRESSED, 4); - MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], 'L', PRESSED); + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], MENU_HAS_NO_CURSOR, 5); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], MenuText_ADMINCHANGEPINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_CHANGEPIN_SECOND_INSERT, NULL); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], 'X', PRESSED, RM_ADMINMENU); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '0', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '1', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '2', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '3', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '4', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '5', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '6', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '7', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '8', PRESSED, 4); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '9', PRESSED, 4); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], 'E', PRESSED, repairMenu_configConfirmSecondPin); /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -1055,7 +1822,14 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_INTERLOCK, NULL); MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_IO_SOLENOID, NULL); MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_IO_VOLTAGE_IN, NULL); - MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_IO_VOLTAGE_OUT, NULL); + if (PCBA_getInstance()->pcba == PCBA_Tesla) + { + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2, repairMenu_configVoltageOutput); + } + else + { + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1, repairMenu_configVoltageOutput); + } if (PCBA_getInstance()->pcba == PCBA_Tesla) { MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][5], RM_ADMIN_IO_TESLAGUN, NULL); @@ -1099,6 +1873,99 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], '0', RELEASED, repairMenu_solenoidLock); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], 'X', PRESSED, RM_ADMIN_IOCONTROL); + /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + * ADMIN Voltage input + * Allows constant readout of all three ADCs + * Key 'X' returns to I/O menu + * + * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + */ + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], MENU_HAS_NO_CURSOR, 4); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], '0', PRESSED, repairMenu_solenoidUnlock); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], '0', RELEASED, repairMenu_solenoidLock); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], 'X', PRESSED, RM_ADMIN_IOCONTROL); + + /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + * ADMIN Voltage output + * Allows control over all three DACs + * Key 'X' returns to I/O menu + * + * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + */ + if (PCBA_getInstance()->pcba == PCBA_Anode) + { + numberOfDigits = 5; + } + else if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + // The signage adds to the number of digits + numberOfDigits = 5; + } + else if (PCBA_getInstance()->pcba == PCBA_Tesla) + { + numberOfDigits = 4; + } + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'E', PRESSED, repairMenu_configConfirmVoltageOutFirstRow); + if (PCBA_getInstance()->pcba != PCBA_Tesla) + { + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'D', PRESSED, repairMenu_configConfirmVoltageOutFirstRowGotoNext); + } + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'X', PRESSED, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP); + + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'E', PRESSED, repairMenu_configConfirmVoltageOutSecondRow); + if (PCBA_getInstance()->pcba != PCBA_Tesla) + { + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'U', PRESSED, repairMenu_configConfirmVoltageOutSecondRowGotoPrevious); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'D', PRESSED, repairMenu_configConfirmVoltageOutSecondRowGotoNext); + } + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'X', PRESSED, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP); + + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'E', PRESSED, repairMenu_configConfirmVoltageOutThirdRow); + if (PCBA_getInstance()->pcba != PCBA_Tesla) + { + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'U', PRESSED, repairMenu_configConfirmVoltageOutThirdRowGotoPrevious); + } + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'X', PRESSED, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP); + + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP], 'X', PRESSED, RM_ADMIN_IOCONTROL); + /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- * ADMIN Teslagun relais control * @@ -1149,7 +2016,14 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '7', PRESSED, 7); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '8', PRESSED, 8); MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '9', PRESSED, 9); - MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'X', PRESSED, RM_ADMINMENU); + if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) + { + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'X', PRESSED, RM_ADMIN_CATHODEMCP_SELECT); + } + else + { + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'X', PRESSED, RM_ADMINMENU); + } /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- * ADMIN preset config @@ -1157,109 +2031,166 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) * * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- */ - unsigned int numberOfDigits = 0; + int softStartDigits = 0; + int durationDigits = 0; + int voltageDigits = 0; if (PCBA_getInstance()->pcba == PCBA_Anode) { - numberOfDigits = 5; + softStartDigits = 3; + durationDigits = 4; + voltageDigits = 5; } else if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) { - numberOfDigits = 4; + softStartDigits = 3; + durationDigits = 4; + voltageDigits = 5; } else if (PCBA_getInstance()->pcba == PCBA_Tesla) { - numberOfDigits = 4; + softStartDigits = 3; + durationDigits = 4; + voltageDigits = 4; } MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], MENU_HAS_NO_CURSOR, 10); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '0', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '1', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '2', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '3', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '4', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '5', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '6', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '7', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '8', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '0', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '1', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '2', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '3', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '4', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '5', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '6', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '7', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '8', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '9', PRESSED, softStartDigits); MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], 'L', PRESSED); MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], 'E', PRESSED, repairMenu_configConfirmPresetFirstSoftstart); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT); MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], MENU_HAS_NO_CURSOR, 10); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '0', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '1', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '2', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '3', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '4', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '5', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '6', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '7', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '8', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '0', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '1', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '2', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '3', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '4', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '5', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '6', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '7', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '8', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '9', PRESSED, durationDigits); MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], 'L', PRESSED); MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], 'E', PRESSED, repairMenu_configConfirmPresetFirstDuration); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT); MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], MENU_HAS_NO_CURSOR, 10); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '0', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '1', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '2', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '3', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '4', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '5', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '6', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '7', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '8', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '0', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '1', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '2', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '3', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '4', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '5', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '6', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '7', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '8', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '9', PRESSED, voltageDigits); MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], 'L', PRESSED); MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], 'E', PRESSED, repairMenu_configConfirmPresetFirstVoltage); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT); MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], MENU_HAS_NO_CURSOR, 10); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '0', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '1', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '2', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '3', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '4', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '5', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '6', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '7', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '8', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '0', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '1', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '2', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '3', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '4', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '5', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '6', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '7', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '8', PRESSED, softStartDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '9', PRESSED, softStartDigits); MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], 'L', PRESSED); MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], 'E', PRESSED, repairMenu_configConfirmPresetSecondSoftstart); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT); MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], MENU_HAS_NO_CURSOR, 10); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '0', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '1', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '2', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '3', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '4', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '5', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '6', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '7', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '8', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '0', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '1', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '2', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '3', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '4', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '5', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '6', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '7', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '8', PRESSED, durationDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '9', PRESSED, durationDigits); MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], 'L', PRESSED); MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], 'E', PRESSED, repairMenu_configConfirmPresetSecondDuration); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT); MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], MENU_HAS_NO_CURSOR, 10); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '0', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '1', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '2', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '3', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '4', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '5', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '6', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '7', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '8', PRESSED, numberOfDigits); - MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '0', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '1', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '2', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '3', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '4', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '5', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '6', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '7', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '8', PRESSED, voltageDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '9', PRESSED, voltageDigits); MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], 'L', PRESSED); MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], 'E', PRESSED, repairMenu_configConfirmPresetSecondVoltage); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT); + + numberOfDigits = 5; + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], 'E', PRESSED, repairMenu_configConfirmPIDKp); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], 'X', PRESSED, RM_ADMINMENU); + + numberOfDigits = 5; + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], 'E', PRESSED, repairMenu_configConfirmPIDKi); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], 'X', PRESSED, RM_ADMINMENU); + + numberOfDigits = 5; + MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], 'E', PRESSED, repairMenu_configConfirmPIDKd); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], 'X', PRESSED, RM_ADMINMENU); + /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- * ADMIN INFORMATION & VERSION SCREEN * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -1272,7 +2203,27 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) - + /* ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + * CALIBRATION PIN VERIFICATION + * This screen is designed in a dedicated function + * + * ------------------------------------------------------------------------------------------------------------------------------------------------------------------- + */ + numberOfDigits = PIN_NUMBER_OF_DIGITS; + MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '0', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '1', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '2', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '3', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '4', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '5', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '6', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '7', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '8', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '9', PRESSED, numberOfDigits); + MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], 'L', PRESSED); + MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], 'E', PRESSED, repairMenu_confirmCalibrationPin); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], 'X', PRESSED, RM_MAINMENU); @@ -1300,6 +2251,9 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore) MenuElements_createMenuPage(&menuCore->menuArray[RM_ERROR_STATE], MENU_HAS_NO_CURSOR, 4); MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ERROR_STATE], 'X', PRESSED, RM_MAINMENU); + MenuElements_createMenuPage(&menuCore->menuArray[RM_WARNING_STATE], MENU_HAS_NO_CURSOR, 4); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_WARNING_STATE], 'X', PRESSED, repairMenu_gotoLastState); + } diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c index 7fd5ada..980bec0 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c +++ b/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) - { - } - else if (errorCode == REPAIR_FAIL) + switch (errorCode) { - 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; } diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c index 784bdee..5e46d00 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c +++ b/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 { diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcesses.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcesses.c index 22229f3..8914b06 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcesses.c +++ b/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); - - // DISABLE external power - Power6V5Supply_off(); + hsb_disableSafety(); repairProcess_destruct(&mainRepairProcess); Observable_deleteObserver(RTC_getObservable(rtc), repairProcesses_feedMainRepairProcessSecondsCounter);