private/hsb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated memory storage functionality

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

Next: Preset update functionality from menu 

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@269 05563f52-14a8-4384-a975-3d1654cca0fa
This commit is contained in:
mmi
2017-11-02 12:58:27 +00:00
parent 76783a6061
commit 4901cb1a09
27 changed files with 894 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

69
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPreset.c Normal file
View File

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

320
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/RepairPresets.c Normal file
View File

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

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

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

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

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

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

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

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

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

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

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