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/Makefile
View File

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

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

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

21
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairPreset.h → S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/RepairPreset.h
View File

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

120
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/RepairPresets.h Normal file
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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"