c-style-checker

@@ -1 +1 @@
-Subproject commit aeb2707d80049094337742d0f62cd24dbef1c01d
+Subproject commit cb937262aa71ee3d610900d7f14eef28e9f11dd0

stm-firmware/.gitignore

@@ -16,10 +16,3 @@ reflow-controller.includes
 *.files
 *.user.*
 *.user
-
-# VSCODE and CLANGD sepcific excludes
-
-.vscode/
-build/
-.cache/
-compile_commands.json

stm-firmware/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Generic)
 set(CMAKE_SYSTEM_PROCESSOR arm)
 set(CMAKE_CROSSCOMPILING 1)
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.0)
 
 set(CMAKE_TOOLCHAIN_FILE "arm-none-eabi-gcc.cmake")
 
@@ -38,16 +38,31 @@ if (GIT_FOUND)
 	)
 	message("${BoldGreen}Git based version number: ${GIT_DESCRIBE}${ColorReset}")
 else (GIT_FOUND)
+	set(GIT_DESCRIBE "v0.0.0-unknown")
 	message("${BoldRed}No git installation found. It is highly recommended using git to generate the version number")
-	message(FATAL_ERROR "Git is required")
+	message("Version is set to: ${GIT_DESCRIBE}${ColorReset}")
 endif (GIT_FOUND)
 
-find_program(PATCHELFCRC patchelfcrc)
-if (PATCHELFCRC)
-	message("patchelfcrc found: ${PATCHELFCRC}")
-else(PATCHELFCRC)
-	message(FATAL_ERROR "${BoldRed}Patchelfcrc not found. Cannot patch CRC checksum into ELF file: patchelfcrc: command not found! See: https://git.shimatta.de/mhu/patchelfcrc${ColorReset}")
-endif (PATCHELFCRC)
+find_program(VIRTUALENV virtualenv)
+if (VIRTUALENV)
+	message("Python virtual environment found")
+	execute_process(
+		COMMAND ${VIRTUALENV} venv
+		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+		OUTPUT_QUIET
+		COMMAND_ERROR_IS_FATAL ANY
+	)
+	set(VENV_BIN "${CMAKE_CURRENT_BINARY_DIR}/venv/bin")
+	execute_process(
+		COMMAND ./pip install -r "${CMAKE_CURRENT_SOURCE_DIR}/crc-patcher/requirements.txt"
+		WORKING_DIRECTORY ${VENV_BIN}
+		OUTPUT_QUIET
+		COMMAND_ERROR_IS_FATAL ANY
+	)
+	message("${BoldGreen}python virtual environment set up!${ColorReset}")
+else(VIRTUALENV)
+	message(FATAL_ERROR "${BoldRed}Python virtual environment not set up: virtualenv: command not found!${ColorReset}")
+endif (VIRTUALENV)
 
 
 set(ELFFILE ${PROJECT_NAME}.elf)
@@ -56,10 +71,11 @@ set(MAPFILE ${PROJECT_NAME}.map)
 set(LINKER_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/stm32f407vet6_flash.ld)
 
 add_compile_options(-Wall -Wextra -Wold-style-declaration -Wuninitialized -Wmaybe-uninitialized -Wunused-parameter)
-add_compile_options(-mlittle-endian -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles -Wimplicit-fallthrough=3 -Wsign-compare)
+add_compile_options(-mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles -Wimplicit-fallthrough=3 -Wsign-compare)
 
 
-add_definitions(-DBASE64_LOOKUP_TABLE_SECTION=\".ccm.bss\" -DSHELLMATTA_HELP_ALIAS=\"?\" -DHSE_VALUE=8000000UL -DSTM32F407xx -DSTM32F4XX -DARM_MATH_CM4)
+set(GIT_DESCRIBE "${GIT_DESCRIBE}")
+add_definitions(-DBASE64_LOOKUP_TABLE_SECTION=\".ccm.bss\" -DSHELLMATTA_HELP_ALIAS=\"?\" -DGIT_VER=${GIT_DESCRIBE} -DHSE_VALUE=8000000UL -DSTM32F407xx -DSTM32F4XX -DARM_MATH_CM4)
 
 add_subdirectory(doxygen)
 add_subdirectory(updater/ram-code)
@@ -99,35 +115,24 @@ aux_source_directory("shellmatta/src" SHELLMATTA_SRCS)
 aux_source_directory("updater" UPDATER_SRCS)
 aux_source_directory("temp-profile" PROFILE_SRCS)
 
-set(GEN_VERSION_HEADER_PATH "${CMAKE_CURRENT_BINARY_DIR}/include/generated-version")
-
-
-add_custom_target(
-	generate-version-header
-	COMMAND mkdir -p ${GEN_VERSION_HEADER_PATH} && bash "${CMAKE_CURRENT_SOURCE_DIR}/create_version_header.sh" "${GEN_VERSION_HEADER_PATH}/version.h"
-	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-	COMMENT "Generating version number using git"
-)
-
 add_executable(${ELFFILE} ${MAIN_SOURCES} ${CFG_PARSER_SRCS} ${UI_SRCS}
 			${FAT_SRCS} ${SDIO_SRCS} ${BOOT_SRCS} ${SETUP_SRCS}
 			${STM_PERIPH_SRCS} ${SETTINGS_SRCS} ${SAFETY_SRCS}
 			${SHELLMATTA_SRCS} ${UPDATER_SRCS} ${PROFILE_SRCS}
 		)
 	
-add_dependencies(${ELFFILE} updater-ram-code-header-blob generate-version-header)
-
+add_dependencies(${ELFFILE} updater-ram-code-header-blob)		
 
 target_include_directories(${ELFFILE} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/shellmatta/api ${CMAKE_CURRENT_SOURCE_DIR}/config-parser/include)
-target_link_options(${ELFFILE} PRIVATE -mlittle-endian -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 --disable-newlib-supplied-syscalls -nostartfiles -T${LINKER_SCRIPT} -Wl,--print-memory-usage)
+target_link_options(${ELFFILE} PRIVATE -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork -mfloat-abi=hard -mfpu=fpv4-sp-d16 --disable-newlib-supplied-syscalls -nostartfiles -T${LINKER_SCRIPT} -Wl,--print-memory-usage)
 target_link_libraries(${ELFFILE} base64-lib linklist-lib)
-target_include_directories(${ELFFILE} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/updater/ram-code/include/" "${CMAKE_CURRENT_BINARY_DIR}/include/")
+target_include_directories(${ELFFILE} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/updater/ram-code/include/")
 
 add_custom_command(
     TARGET ${ELFFILE}
     POST_BUILD
-    COMMAND ${PATCHELFCRC} --little-endian --verbose --granularity word --start-magic 0xa8be53f9 --end-magic 0xffa582ff -O .flashcrc -p crc-32-mpeg -S .text -S .data -S .ccmdata -S .vectors "${CMAKE_CURRENT_BINARY_DIR}/${ELFFILE}"
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMAND ./python "${CMAKE_CURRENT_SOURCE_DIR}/crc-patcher/crc-patch-elf.py" "${CMAKE_CURRENT_BINARY_DIR}/${ELFFILE}"
+    WORKING_DIRECTORY ${VENV_BIN}
     COMMENT "Running Flash CRC Patcher"
     )
 

stm-firmware/config-parser/config-parser.c

@@ -28,14 +28,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-/**
- * @brief Config parser magic value used to check sanity of passed structs
- */
 #define CONFIG_PARSER_MAGIC 0x464a6e2bUL
-
-/**
- * @brief Config parser type casting macro
- */
 #define CONFIG_PARSER(p) ((struct config_parser *)(p))
 
 /**
@@ -44,8 +37,7 @@
  * If the pointer is invalid, the function using this macro will return with
  * CONFIG_PARSER_PARAM_ERR
  */
-#define config_parser_check_handle(handle) do { \
-	if (!(handle) || \
+#define config_parser_check_handle(handle) do { if (!(handle) || \
 						((struct config_parser *)(handle))->magic != CONFIG_PARSER_MAGIC) \
 							return CONFIG_PARSER_PARAM_ERR; \
 						} while (0)
@@ -100,17 +92,17 @@ static int parse_value(struct config_parser_entry *entry, char *value_start_toke
 	if (value_start_token[0] != '-') {
 		/* Try parsing as ul */
 		entry->value.uint_val = strtoul(value_start_token, &endptr, 0);
-		if (endptr == value_start_token)
+		if (endptr == value_start_token) {
 			return -1;
-
+		}
 		entry->type = CONFIG_PARSER_TYPE_UINT;
 		goto exit;
 	} else {
 		/* Try parsing as int */
 		entry->value.int_val = strtod(value_start_token, &endptr);
-		if (endptr == value_start_token)
+		if (endptr == value_start_token) {
 			return -1;
-
+		}
 		entry->type = CONFIG_PARSER_TYPE_INT;
 	}
 
@@ -118,15 +110,13 @@ exit:
 	return 0;
 }
 
-enum config_parser_ret config_parser_get_line(config_parser_handle_t handle, struct config_parser_entry *entry,
-					      bool force_float)
+enum config_parser_ret config_parser_get_line(config_parser_handle_t handle, struct config_parser_entry *entry, bool force_float)
 {
 	struct config_parser *p;
-	char *token;
-	int token_round = 0;
-
 	config_parser_check_handle(handle);
 	p = CONFIG_PARSER(handle);
+	char *token;
+	int token_round = 0;
 
 	if (!entry)
 		return CONFIG_PARSER_PARAM_ERR;
@@ -141,6 +131,7 @@ enum config_parser_ret config_parser_get_line(config_parser_handle_t handle, str
 		if (token[0] == '#') {
 			if (token_round == 0)
 				return CONFIG_PARSER_LINE_COMMENT;
+			else
 				break;
 		}
 
@@ -149,8 +140,9 @@ enum config_parser_ret config_parser_get_line(config_parser_handle_t handle, str
 			entry->name = token;
 			break;
 		case 1: /* = Symbol */
-			if (strcmp(token, "="))
+			if (strcmp(token, "=")) {
 				return CONFIG_PARSER_LINE_MALFORM;
+			}
 			break;
 		case 2: /* VALUE */
 			if (parse_value(entry, token))
@@ -180,7 +172,6 @@ enum config_parser_ret config_parser_reset_to_start(config_parser_handle_t handl
 {
 	FRESULT res;
 	struct config_parser *p;
-
 	config_parser_check_handle(handle);
 	p = CONFIG_PARSER(handle);
 
@@ -203,7 +194,6 @@ enum config_parser_ret config_parser_close_file(config_parser_handle_t handle)
 {
 	struct config_parser *p;
 	FRESULT res;
-
 	config_parser_check_handle(handle);
 	p = CONFIG_PARSER(handle);
 

stm-firmware/crc-patcher/crc-patch-elf.py

@@ -0,0 +1,114 @@
+#!/bin/python
+
+"""
+This script patches the CRC checksums into an existing ELF file.
+
+For this, it searches the follwoing sections:
+	1) .text
+	2) .data
+	3) .ccmdata
+	4) .vectors
+
+All sections MUST be a multiple of 4 bytes long because the CRC calculation relies on whole 32 bit words.
+The sections are excrated and the CRC is calculated for each section.
+
+In the section .flashcrc, the script expects a single struct with the prototype:
+struct flash_crcs {
+	uint32_t start_magic;
+	uint32_t crc_section_text;
+	uint32_t crc_section_data;
+	uint32_t crc_section_ccm_data;
+	uint32_t crc_section_vectors;
+	uint32_t end_magic;
+};
+
+It checks, if the start magic and end magic are set to the appropriate values and then patches in the CRC values of the sections.
+The magic values checked for are: 0xA8BE53F9 and 0xFFA582FF
+"""
+from elftools.elf.elffile import ELFFile
+from elftools.elf.segments import Segment
+import elftools.elf.constants as elf_const
+import sys
+import crcmod
+import crcmod.predefined
+import struct
+
+crc_calc = crcmod.predefined.mkCrcFun('crc-32-mpeg')
+
+if len(sys.argv) < 2:
+	print("Usage:", sys.argv[0], ' <elf file>')
+	sys.exit(-1)
+
+filename=sys.argv[1]
+
+def section_calculate_crc(section):
+	data = bytearray(section.data())
+	be_data = bytearray([0 for k in range(0, len(data))])
+	# Rearrange data, because the STM controller sees it as 32 bit little endian words
+	for i in range(0, int(len(data)/4)):
+		be_data[i*4+0] = data[i*4+3]
+		be_data[i*4+1] = data[i*4+2]
+		be_data[i*4+2] = data[i*4+1]
+		be_data[i*4+3] = data[i*4+0]
+
+	return crc_calc(be_data)
+
+with open(filename, 'r+b') as f:
+	elf = ELFFile(f)
+	sections = {}
+	sections['.text'] = elf.get_section_by_name('.text')
+	sections['.data'] = elf.get_section_by_name('.data')
+	sections['.ccmdata'] = elf.get_section_by_name('.ccmdata')
+	sections['.vectors'] = elf.get_section_by_name('.vectors')
+
+	for key, sec in sections.items():
+		if sec is None:
+			print("Error! Section", key, "not found in ELF file!")
+			sys.exit(-1)
+		print('Found section', key, 'Size:',
+			  sec.data_size, 'Type:', sec['sh_type'])
+		if sec['sh_type'] != 'SHT_PROGBITS':
+			print('Error! Section must be of type SHT_PROGBITS')
+			sys.exit(-1)
+		if (sec.data_size % 4 != 0):
+			print("Section", key, "has wrong size. Must be a multiple of 4 bytes!")
+			sys.exit(-1)
+
+	text_crc = section_calculate_crc(sections['.text'])
+	print('CRC of .text section:', hex(text_crc))
+	data_crc = section_calculate_crc(sections['.data'])
+	print('CRC of .data section:', hex(data_crc))
+	ccmdata_crc = section_calculate_crc(sections['.ccmdata'])
+	print('CRC of .ccmdata section:', hex(ccmdata_crc))
+	vextors_crc = section_calculate_crc(sections['.vectors'])
+	print('CRC of .vectors section:', hex(vextors_crc))
+
+	# Check the flashcrc section
+	flashcrc_sec = elf.get_section_by_name('.flashcrc')
+	if flashcrc_sec is None:
+		print('Section for flash CRC missing!')
+		sys.exit(-1)
+	if flashcrc_sec.data_size != 6*4:
+		print("Error: .flashcrc section has wrong size:",flashcrc_sec.data_size)
+		sys.exit(-1);
+
+	crc_sec_data = bytearray(flashcrc_sec.data())
+	magic1 = struct.unpack('<I'*1, bytes(crc_sec_data[0:4]))[0]
+	magic2 = struct.unpack('<I'*1, bytes(crc_sec_data[-4:]))[0]
+	print("CRC section magic values:", hex(magic1), hex(magic2))
+	if magic1 != 0xA8BE53F9 or magic2 != 0xFFA582FF:
+		print("Wrong magics in CRC section. Data misalignment?")
+		sys.exit(-2)
+
+	crc_sec_offset = flashcrc_sec['sh_offset']
+	print('CRC section ELF file offset:', hex(crc_sec_offset))
+	
+	crc_sec_data[4:8] = struct.pack('<I',text_crc)
+	crc_sec_data[8:12] = struct.pack('<I',data_crc)
+	crc_sec_data[12:16] = struct.pack('<I',ccmdata_crc)
+	crc_sec_data[16:20] = struct.pack('<I',vextors_crc)
+	f.seek(crc_sec_offset)
+	f.write(crc_sec_data)
+	print('CRCs patched successfully')
+
+	

stm-firmware/crc-patcher/requirements.txt

@@ -0,0 +1,2 @@
+crcmod==1.7
+pyelftools==0.27

stm-firmware/create-c-file-with-header.py

@@ -6,7 +6,7 @@ import pathlib
 
 license_header = """/* Reflow Oven Controller
 *
-* Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
 *
 * This file is part of the Reflow Oven Controller Project.
 *
@@ -37,7 +37,7 @@ cpath = os.path.join(project_dir, sys.argv[1]+'.c')
 hfile = sys.argv[1]+'.h'
 hpath = os.path.join(module_include_dir, hfile)
 
-h_define = '_'+hfile.replace('.', '_').replace('-', '_').replace('/', '_').upper()+'_'
+h_define = '__'+hfile.replace('.', '_').replace('-', '_').replace('/', '_').upper()+'__'
 
 if os.path.exists(cpath) or os.path.exists(hpath):
 	print("File already exists! Abort!")

stm-firmware/create_version_header.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-if [[ -z $1 ]]; then
-	# Exit with error in case no output file is specified
-	exit -1
-fi
-
-firmware_version=`git describe --tags --always --dirty`
-commit=`git rev-parse HEAD`
-
-echo "#ifndef _VERSION_GENERATED_H_" > $1
-echo "#define _VERSION_GENERATED_H_" >> $1
-echo "#define GIT_VERSION_STRING \"$firmware_version\"" >> $1
-echo "#define GIT_FULL_COMMIT \"$commit\"" >> $1
-echo "#endif /* _VERSION_GENERATED_H_ */" >> $1

stm-firmware/fatfs/ffsystem.c

@@ -1,208 +1,170 @@
 /*------------------------------------------------------------------------*/
-/* A Sample Code of User Provided OS Dependent Functions for FatFs        */
+/* Sample Code of OS Dependent Functions for FatFs                        */
+/* (C)ChaN, 2018                                                          */
 /*------------------------------------------------------------------------*/
 
+
 #include <fatfs/ff.h>
 
 
-#if FF_USE_LFN == 3	/* Use dynamic memory allocation */
+#if FF_USE_LFN == 3	/* Dynamic memory allocation */
 
 /*------------------------------------------------------------------------*/
-/* Allocate/Free a Memory Block                                           */
+/* Allocate a memory block                                                */
 /*------------------------------------------------------------------------*/
 
-#include <stdlib.h>		/* with POSIX API */
-
-
 void* ff_memalloc (	/* Returns pointer to the allocated memory block (null if not enough core) */
 	UINT msize		/* Number of bytes to allocate */
 )
 {
-	return malloc((size_t)msize);	/* Allocate a new memory block */
+	return malloc(msize);	/* Allocate a new memory block with POSIX API */
 }
 
 
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+
 void ff_memfree (
-	void* mblock	/* Pointer to the memory block to free (no effect if null) */
+	void* mblock	/* Pointer to the memory block to free (nothing to do if null) */
 )
 {
-	free(mblock);	/* Free the memory block */
+	free(mblock);	/* Free the memory block with POSIX API */
 }
 
 #endif
 
 
 
-
 #if FF_FS_REENTRANT	/* Mutal exclusion */
-/*------------------------------------------------------------------------*/
-/* Definitions of Mutex                                                   */
-/*------------------------------------------------------------------------*/
-
-#define OS_TYPE	0	/* 0:Win32, 1:uITRON4.0, 2:uC/OS-II, 3:FreeRTOS, 4:CMSIS-RTOS */
-
-
-#if   OS_TYPE == 0	/* Win32 */
-#include <windows.h>
-static HANDLE Mutex[FF_VOLUMES + 1];	/* Table of mutex handle */
-
-#elif OS_TYPE == 1	/* uITRON */
-#include "itron.h"
-#include "kernel.h"
-static mtxid Mutex[FF_VOLUMES + 1];		/* Table of mutex ID */
-
-#elif OS_TYPE == 2	/* uc/OS-II */
-#include "includes.h"
-static OS_EVENT *Mutex[FF_VOLUMES + 1];	/* Table of mutex pinter */
-
-#elif OS_TYPE == 3	/* FreeRTOS */
-#include "FreeRTOS.h"
-#include "semphr.h"
-static SemaphoreHandle_t Mutex[FF_VOLUMES + 1];	/* Table of mutex handle */
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-#include "cmsis_os.h"
-static osMutexId Mutex[FF_VOLUMES + 1];	/* Table of mutex ID */
-
-#endif
-
-
 
 /*------------------------------------------------------------------------*/
-/* Create a Mutex                                                         */
+/* Create a Synchronization Object                                        */
 /*------------------------------------------------------------------------*/
-/* This function is called in f_mount function to create a new mutex
-/  or semaphore for the volume. When a 0 is returned, the f_mount function
-/  fails with FR_INT_ERR.
+/* This function is called in f_mount() function to create a new
+/  synchronization object for the volume, such as semaphore and mutex.
+/  When a 0 is returned, the f_mount() function fails with FR_INT_ERR.
 */
 
-int ff_mutex_create (	/* Returns 1:Function succeeded or 0:Could not create the mutex */
-	int vol				/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+//const osMutexDef_t Mutex[FF_VOLUMES];	/* Table of CMSIS-RTOS mutex */
+
+
+int ff_cre_syncobj (	/* 1:Function succeeded, 0:Could not create the sync object */
+	BYTE vol,			/* Corresponding volume (logical drive number) */
+	FF_SYNC_t* sobj		/* Pointer to return the created sync object */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	Mutex[vol] = CreateMutex(NULL, FALSE, NULL);
-	return (int)(Mutex[vol] != INVALID_HANDLE_VALUE);
+	/* Win32 */
+	*sobj = CreateMutex(NULL, FALSE, NULL);
+	return (int)(*sobj != INVALID_HANDLE_VALUE);
 
-#elif OS_TYPE == 1	/* uITRON */
-	T_CMTX cmtx = {TA_TPRI,1};
+	/* uITRON */
+//	T_CSEM csem = {TA_TPRI,1,1};
+//	*sobj = acre_sem(&csem);
+//	return (int)(*sobj > 0);
 
-	Mutex[vol] = acre_mtx(&cmtx);
-	return (int)(Mutex[vol] > 0);
+	/* uC/OS-II */
+//	OS_ERR err;
+//	*sobj = OSMutexCreate(0, &err);
+//	return (int)(err == OS_NO_ERR);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OS_ERR err;
+	/* FreeRTOS */
+//	*sobj = xSemaphoreCreateMutex();
+//	return (int)(*sobj != NULL);
 
-	Mutex[vol] = OSMutexCreate(0, &err);
-	return (int)(err == OS_NO_ERR);
-
-#elif OS_TYPE == 3	/* FreeRTOS */
-	Mutex[vol] = xSemaphoreCreateMutex();
-	return (int)(Mutex[vol] != NULL);
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	osMutexDef(cmsis_os_mutex);
-
-	Mutex[vol] = osMutexCreate(osMutex(cmsis_os_mutex));
-	return (int)(Mutex[vol] != NULL);
-
-#endif
+	/* CMSIS-RTOS */
+//	*sobj = osMutexCreate(&Mutex[vol]);
+//	return (int)(*sobj != NULL);
 }
 
 
 /*------------------------------------------------------------------------*/
-/* Delete a Mutex                                                         */
+/* Delete a Synchronization Object                                        */
 /*------------------------------------------------------------------------*/
-/* This function is called in f_mount function to delete a mutex or
-/  semaphore of the volume created with ff_mutex_create function.
+/* This function is called in f_mount() function to delete a synchronization
+/  object that created with ff_cre_syncobj() function. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
 */
 
-void ff_mutex_delete (	/* Returns 1:Function succeeded or 0:Could not delete due to an error */
-	int vol				/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+int ff_del_syncobj (	/* 1:Function succeeded, 0:Could not delete due to an error */
+	FF_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	CloseHandle(Mutex[vol]);
+	/* Win32 */
+	return (int)CloseHandle(sobj);
 
-#elif OS_TYPE == 1	/* uITRON */
-	del_mtx(Mutex[vol]);
+	/* uITRON */
+//	return (int)(del_sem(sobj) == E_OK);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OS_ERR err;
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);
+//	return (int)(err == OS_NO_ERR);
 
-	OSMutexDel(Mutex[vol], OS_DEL_ALWAYS, &err);
+	/* FreeRTOS */
+//  vSemaphoreDelete(sobj);
+//	return 1;
 
-#elif OS_TYPE == 3	/* FreeRTOS */
-	vSemaphoreDelete(Mutex[vol]);
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	osMutexDelete(Mutex[vol]);
-
-#endif
+	/* CMSIS-RTOS */
+//	return (int)(osMutexDelete(sobj) == osOK);
 }
 
 
 /*------------------------------------------------------------------------*/
-/* Request a Grant to Access the Volume                                   */
+/* Request Grant to Access the Volume                                     */
 /*------------------------------------------------------------------------*/
-/* This function is called on enter file functions to lock the volume.
+/* This function is called on entering file functions to lock the volume.
 /  When a 0 is returned, the file function fails with FR_TIMEOUT.
 */
 
-int ff_mutex_take (	/* Returns 1:Succeeded or 0:Timeout */
-	int vol			/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
+	FF_SYNC_t sobj	/* Sync object to wait */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	return (int)(WaitForSingleObject(Mutex[vol], FF_FS_TIMEOUT) == WAIT_OBJECT_0);
+	/* Win32 */
+	return (int)(WaitForSingleObject(sobj, FF_FS_TIMEOUT) == WAIT_OBJECT_0);
 
-#elif OS_TYPE == 1	/* uITRON */
-	return (int)(tloc_mtx(Mutex[vol], FF_FS_TIMEOUT) == E_OK);
+	/* uITRON */
+//	return (int)(wai_sem(sobj) == E_OK);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OS_ERR err;
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexPend(sobj, FF_FS_TIMEOUT, &err));
+//	return (int)(err == OS_NO_ERR);
 
-	OSMutexPend(Mutex[vol], FF_FS_TIMEOUT, &err));
-	return (int)(err == OS_NO_ERR);
+	/* FreeRTOS */
+//	return (int)(xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);
 
-#elif OS_TYPE == 3	/* FreeRTOS */
-	return (int)(xSemaphoreTake(Mutex[vol], FF_FS_TIMEOUT) == pdTRUE);
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	return (int)(osMutexWait(Mutex[vol], FF_FS_TIMEOUT) == osOK);
-
-#endif
+	/* CMSIS-RTOS */
+//	return (int)(osMutexWait(sobj, FF_FS_TIMEOUT) == osOK);
 }
 
 
-
 /*------------------------------------------------------------------------*/
-/* Release a Grant to Access the Volume                                   */
+/* Release Grant to Access the Volume                                     */
 /*------------------------------------------------------------------------*/
-/* This function is called on leave file functions to unlock the volume.
+/* This function is called on leaving file functions to unlock the volume.
 */
 
-void ff_mutex_give (
-	int vol			/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+void ff_rel_grant (
+	FF_SYNC_t sobj	/* Sync object to be signaled */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	ReleaseMutex(Mutex[vol]);
+	/* Win32 */
+	ReleaseMutex(sobj);
 
-#elif OS_TYPE == 1	/* uITRON */
-	unl_mtx(Mutex[vol]);
+	/* uITRON */
+//	sig_sem(sobj);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OSMutexPost(Mutex[vol]);
+	/* uC/OS-II */
+//	OSMutexPost(sobj);
 
-#elif OS_TYPE == 3	/* FreeRTOS */
-	xSemaphoreGive(Mutex[vol]);
+	/* FreeRTOS */
+//	xSemaphoreGive(sobj);
 
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	osMutexRelease(Mutex[vol]);
-
-#endif
+	/* CMSIS-RTOS */
+//	osMutexRelease(sobj);
 }
 
-#endif	/* FF_FS_REENTRANT */
+#endif
 

stm-firmware/fatfs/ffunicode.c

@@ -1,13 +1,13 @@
 /*------------------------------------------------------------------------*/
-/* Unicode Handling Functions for FatFs R0.13 and Later                   */
-/*------------------------------------------------------------------------*/
-/* This module will occupy a huge memory in the .rodata section when the  */
-/* FatFs is configured for LFN with DBCS. If the system has a Unicode     */
-/* library for the code conversion, this module should be modified to use */
-/* it to avoid silly memory consumption.                                  */
+/* Unicode handling functions for FatFs R0.13+                            */
 /*------------------------------------------------------------------------*/
+/* This module will occupy a huge memory in the .const section when the    /
+/  FatFs is configured for LFN with DBCS. If the system has any Unicode    /
+/  utilitiy for the code conversion, this module should be modified to use /
+/  that function to avoid silly memory consumption.                        /
+/-------------------------------------------------------------------------*/
 /*
-/ Copyright (C) 2022, ChaN, all right reserved.
+/ Copyright (C) 2014, ChaN, all right reserved.
 /
 / FatFs module is an open source software. Redistribution and use of FatFs in
 / source and binary forms, with or without modification, are permitted provided
@@ -25,7 +25,7 @@
 
 #include <fatfs/ff.h>
 
-#if FF_USE_LFN != 0	/* This module will be blanked if in non-LFN configuration */
+#if FF_USE_LFN	/* This module will be blanked if non-LFN configuration */
 
 #define MERGE2(a, b) a ## b
 #define CVTBL(tbl, cp) MERGE2(tbl, cp)
@@ -15214,8 +15214,8 @@ static const WCHAR uc869[] = {	/*  CP869(Greek 2) to Unicode conversion table */
 
 
 /*------------------------------------------------------------------------*/
-/* OEM <==> Unicode Conversions for Static Code Page Configuration with   */
-/* SBCS Fixed Code Page                                                   */
+/* OEM <==> Unicode conversions for static code page configuration        */
+/* SBCS fixed code page                                                   */
 /*------------------------------------------------------------------------*/
 
 #if FF_CODE_PAGE != 0 && FF_CODE_PAGE < 900
@@ -15225,7 +15225,7 @@ WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
 )
 {
 	WCHAR c = 0;
-	const WCHAR* p = CVTBL(uc, FF_CODE_PAGE);
+	const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);
 
 
 	if (uni < 0x80) {	/* ASCII? */
@@ -15247,7 +15247,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 )
 {
 	WCHAR c = 0;
-	const WCHAR* p = CVTBL(uc, FF_CODE_PAGE);
+	const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);
 
 
 	if (oem < 0x80) {	/* ASCII? */
@@ -15267,8 +15267,8 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 
 
 /*------------------------------------------------------------------------*/
-/* OEM <==> Unicode Conversions for Static Code Page Configuration with   */
-/* DBCS Fixed Code Page                                                   */
+/* OEM <==> Unicode conversions for static code page configuration        */
+/* DBCS fixed code page                                                   */
 /*------------------------------------------------------------------------*/
 
 #if FF_CODE_PAGE >= 900
@@ -15277,7 +15277,7 @@ WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0, uc;
 	UINT i = 0, n, li, hi;
 
@@ -15313,7 +15313,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0;
 	UINT i = 0, n, li, hi;
 
@@ -15346,7 +15346,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 
 
 /*------------------------------------------------------------------------*/
-/* OEM <==> Unicode Conversions for Dynamic Code Page Configuration       */
+/* OEM <==> Unicode conversions for dynamic code page configuration       */
 /*------------------------------------------------------------------------*/
 
 #if FF_CODE_PAGE == 0
@@ -15360,7 +15360,7 @@ WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0, uc;
 	UINT i, n, li, hi;
 
@@ -15412,7 +15412,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0;
 	UINT i, n, li, hi;
 
@@ -15458,14 +15458,14 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 
 
 /*------------------------------------------------------------------------*/
-/* Unicode Up-case Conversion                                             */
+/* Unicode up-case conversion                                             */
 /*------------------------------------------------------------------------*/
 
 DWORD ff_wtoupper (	/* Returns up-converted code point */
 	DWORD uni		/* Unicode code point to be up-converted */
 )
 {
-	const WORD* p;
+	const WORD *p;
 	WORD uc, bc, nc, cmd;
 	static const WORD cvt1[] = {	/* Compressed up conversion table for U+0000 - U+0FFF */
 		/* Basic Latin */
@@ -15590,4 +15590,4 @@ DWORD ff_wtoupper (	/* Returns up-converted code point */
 }
 
 
-#endif /* #if FF_USE_LFN != 0 */
+#endif /* #if FF_USE_LFN */

stm-firmware/hw-version-detect.c

@@ -27,15 +27,10 @@
 #include <stm-periph/rcc-manager.h>
 #include <stm32/stm32f4xx.h>
 
-#if HW_REV_DETECT_PIN_LOW > HW_REV_DETECT_PIN_HIGH
-#error Configuration error for Hardware derection pins. Lowest position must be less than the highest pin position.
-#endif
-
 enum hw_revision get_pcb_hardware_version(void)
 {
 	uint8_t current_pin;
-	uint16_t port_bitmask = 0U; /* Use uint16_t because a port can have 16 IOs max. */
-	const uint16_t highest_bit_mask = (1 << (HW_REV_DETECT_PIN_HIGH - HW_REV_DETECT_PIN_LOW));
+	uint16_t port_bitmask = 0U;
 	static enum hw_revision revision = HW_REV_NOT_DETECTED;
 
 	/* If the revision has been previously detected,
@@ -58,7 +53,7 @@ enum hw_revision get_pcb_hardware_version(void)
 	 */
 	for (current_pin = HW_REV_DETECT_PIN_LOW; current_pin <= HW_REV_DETECT_PIN_HIGH; current_pin++) {
 		port_bitmask >>= 1;
-		port_bitmask |= (HW_REV_DETECT_GPIO->IDR & (1 << current_pin)) ? 0x0 : highest_bit_mask;
+		port_bitmask |= (HW_REV_DETECT_GPIO->IDR & (1 << current_pin)) ? 0x0 : 0x80;
 	}
 
 	/* Resolve the read in bitmask to a hardware version */

stm-firmware/include/fatfs/ff.h

@@ -1,8 +1,8 @@
 /*----------------------------------------------------------------------------/
-/  FatFs - Generic FAT Filesystem module  R0.15                               /
+/  FatFs - Generic FAT Filesystem module  R0.14b                              /
 /-----------------------------------------------------------------------------/
 /
-/ Copyright (C) 2022, ChaN, all right reserved.
+/ Copyright (C) 2021, ChaN, all right reserved.
 /
 / FatFs module is an open source software. Redistribution and use of FatFs in
 / source and binary forms, with or without modification, are permitted provided
@@ -20,7 +20,7 @@
 
 
 #ifndef FF_DEFINED
-#define FF_DEFINED	80286	/* Revision ID */
+#define FF_DEFINED	86631	/* Revision ID */
 
 #ifdef __cplusplus
 extern "C" {
@@ -131,11 +131,10 @@ extern const char* VolumeStr[FF_VOLUMES];	/* User defied volume ID */
 
 typedef struct {
 	BYTE	fs_type;		/* Filesystem type (0:not mounted) */
-	BYTE	pdrv;			/* Volume hosting physical drive */
-	BYTE	ldrv;			/* Logical drive number (used only when FF_FS_REENTRANT) */
+	BYTE	pdrv;			/* Associated physical drive */
 	BYTE	n_fats;			/* Number of FATs (1 or 2) */
-	BYTE	wflag;			/* win[] status (b0:dirty) */
-	BYTE	fsi_flag;		/* FSINFO status (b7:disabled, b0:dirty) */
+	BYTE	wflag;			/* win[] flag (b0:dirty) */
+	BYTE	fsi_flag;		/* FSINFO flags (b7:disabled, b0:dirty) */
 	WORD	id;				/* Volume mount ID */
 	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
 	WORD	csize;			/* Cluster size [sectors] */
@@ -148,6 +147,9 @@ typedef struct {
 #if FF_FS_EXFAT
 	BYTE*	dirbuf;			/* Directory entry block scratchpad buffer for exFAT */
 #endif
+#if FF_FS_REENTRANT
+	FF_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
 #if !FF_FS_READONLY
 	DWORD	last_clst;		/* Last allocated cluster */
 	DWORD	free_clst;		/* Number of free clusters */
@@ -161,10 +163,10 @@ typedef struct {
 #endif
 #endif
 	DWORD	n_fatent;		/* Number of FAT entries (number of clusters + 2) */
-	DWORD	fsize;			/* Number of sectors per FAT */
+	DWORD	fsize;			/* Size of an FAT [sectors] */
 	LBA_t	volbase;		/* Volume base sector */
 	LBA_t	fatbase;		/* FAT base sector */
-	LBA_t	dirbase;		/* Root directory base sector (FAT12/16) or cluster (FAT32/exFAT) */
+	LBA_t	dirbase;		/* Root directory base sector/cluster */
 	LBA_t	database;		/* Data base sector */
 #if FF_FS_EXFAT
 	LBA_t	bitbase;		/* Allocation bitmap base sector */
@@ -179,7 +181,7 @@ typedef struct {
 
 typedef struct {
 	FATFS*	fs;				/* Pointer to the hosting volume of this object */
-	WORD	id;				/* Hosting volume's mount ID */
+	WORD	id;				/* Hosting volume mount ID */
 	BYTE	attr;			/* Object attribute */
 	BYTE	stat;			/* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:fragmented in this session, b2:sub-directory stretched) */
 	DWORD	sclust;			/* Object data start cluster (0:no cluster or root directory) */
@@ -248,7 +250,7 @@ typedef struct {
 	WORD	ftime;			/* Modified time */
 	BYTE	fattrib;		/* File attribute */
 #if FF_USE_LFN
-	TCHAR	altname[FF_SFN_BUF + 1];/* Alternative file name */
+	TCHAR	altname[FF_SFN_BUF + 1];/* Altenative file name */
 	TCHAR	fname[FF_LFN_BUF + 1];	/* Primary file name */
 #else
 	TCHAR	fname[12 + 1];	/* File name */
@@ -296,10 +298,8 @@ typedef enum {
 
 
 
-
-/*--------------------------------------------------------------*/
-/* FatFs Module Application Interface                           */
 /*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
 
 FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
 FRESULT f_close (FIL* fp);											/* Close an open file object */
@@ -336,8 +336,6 @@ int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
 int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
 TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the file */
 
-/* Some API fucntions are implemented as macro */
-
 #define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
 #define f_error(fp) ((fp)->err)
 #define f_tell(fp) ((fp)->fptr)
@@ -351,43 +349,38 @@ TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the fil
 
 
 /*--------------------------------------------------------------*/
-/* Additional Functions                                         */
-/*--------------------------------------------------------------*/
+/* Additional user defined functions                            */
 
-/* RTC function (provided by user) */
+/* RTC function */
 #if !FF_FS_READONLY && !FF_FS_NORTC
-DWORD get_fattime (void);	/* Get current time */
+DWORD get_fattime (void);
 #endif
 
-
-/* LFN support functions (defined in ffunicode.c) */
-
-#if FF_USE_LFN >= 1
+/* LFN support functions */
+#if FF_USE_LFN >= 1						/* Code conversion (defined in unicode.c) */
 WCHAR ff_oem2uni (WCHAR oem, WORD cp);	/* OEM code to Unicode conversion */
 WCHAR ff_uni2oem (DWORD uni, WORD cp);	/* Unicode to OEM code conversion */
 DWORD ff_wtoupper (DWORD uni);			/* Unicode upper-case conversion */
 #endif
-
-
-/* O/S dependent functions (samples available in ffsystem.c) */
-
 #if FF_USE_LFN == 3						/* Dynamic memory allocation */
 void* ff_memalloc (UINT msize);			/* Allocate memory block */
 void ff_memfree (void* mblock);			/* Free memory block */
 #endif
-#if FF_FS_REENTRANT	/* Sync functions */
-int ff_mutex_create (int vol);		/* Create a sync object */
-void ff_mutex_delete (int vol);		/* Delete a sync object */
-int ff_mutex_take (int vol);		/* Lock sync object */
-void ff_mutex_give (int vol);		/* Unlock sync object */
+
+/* Sync functions */
+#if FF_FS_REENTRANT
+int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj);	/* Create a sync object */
+int ff_req_grant (FF_SYNC_t sobj);		/* Lock sync object */
+void ff_rel_grant (FF_SYNC_t sobj);		/* Unlock sync object */
+int ff_del_syncobj (FF_SYNC_t sobj);	/* Delete a sync object */
 #endif
 
 
 
 
 /*--------------------------------------------------------------*/
-/* Flags and Offset Address                                     */
-/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
 
 /* File access mode and open method flags (3rd argument of f_open) */
 #define	FA_READ				0x01

stm-firmware/include/fatfs/ffconf.h

@@ -1,8 +1,8 @@
 /*---------------------------------------------------------------------------/
-/  Configurations of FatFs Module
+/  FatFs Functional Configurations
 /---------------------------------------------------------------------------*/
 
-#define FFCONF_DEF	80286	/* Revision ID */
+#define FFCONF_DEF	86631	/* Revision ID */
 
 /*---------------------------------------------------------------------------/
 / Function Configurations
@@ -68,7 +68,7 @@
 /   2: Enable with LF-CRLF conversion.
 /
 /  FF_PRINT_LLI = 1 makes f_printf() support long long argument and FF_PRINT_FLOAT = 1/2
-/  makes f_printf() support floating point argument. These features want C99 or later.
+   makes f_printf() support floating point argument. These features want C99 or later.
 /  When FF_LFN_UNICODE >= 1 with LFN enabled, string functions convert the character
 /  encoding in it. FF_STRF_ENCODE selects assumption of character encoding ON THE FILE
 /  to be read/written via those functions.
@@ -178,7 +178,7 @@
 /  logical drives. Number of items must not be less than FF_VOLUMES. Valid
 /  characters for the volume ID strings are A-Z, a-z and 0-9, however, they are
 /  compared in case-insensitive. If FF_STR_VOLUME_ID >= 1 and FF_VOLUME_STRS is
-/  not defined, a user defined volume string table is needed as:
+/  not defined, a user defined volume string table needs to be defined as:
 /
 /  const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
 */
@@ -190,7 +190,7 @@
 /  number and only an FAT volume found on the physical drive will be mounted.
 /  When this function is enabled (1), each logical drive number can be bound to
 /  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
-/  function will be available. */
+/  funciton will be available. */
 
 
 #define FF_MIN_SS		512
@@ -240,10 +240,10 @@
 #define FF_FS_NORTC		0
 #define FF_NORTC_MON	1
 #define FF_NORTC_MDAY	1
-#define FF_NORTC_YEAR	2022
-/* The option FF_FS_NORTC switches timestamp feature. If the system does not have
-/  an RTC or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable the
-/  timestamp feature. Every object modified by FatFs will have a fixed timestamp
+#define FF_NORTC_YEAR	2020
+/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
+/  any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
+/  the timestamp function. Every object modified by FatFs will have a fixed timestamp
 /  defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
 /  To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
 /  added to the project to read current time form real-time clock. FF_NORTC_MON,
@@ -253,7 +253,7 @@
 
 #define FF_FS_NOFSINFO	0
 /* If you need to know correct free space on the FAT32 volume, set bit 0 of this
-/  option, and f_getfree() function at the first time after volume mount will force
+/  option, and f_getfree() function at first time after volume mount will force
 /  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
 /
 /  bit0=0: Use free cluster count in the FSINFO if available.
@@ -275,21 +275,26 @@
 /      lock control is independent of re-entrancy. */
 
 
+/* #include <somertos.h>	// O/S definitions */
 #define FF_FS_REENTRANT	0
 #define FF_FS_TIMEOUT	1000
+#define FF_SYNC_t		HANDLE
 /* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
 /  module itself. Note that regardless of this option, file access to different
 /  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
 /  and f_fdisk() function, are always not re-entrant. Only file/directory access
-/  to the same volume is under control of this featuer.
+/  to the same volume is under control of this function.
 /
-/   0: Disable re-entrancy. FF_FS_TIMEOUT have no effect.
+/   0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
 /   1: Enable re-entrancy. Also user provided synchronization handlers,
-/      ff_mutex_create(), ff_mutex_delete(), ff_mutex_take() and ff_mutex_give()
-/      function, must be added to the project. Samples are available in ffsystem.c.
+/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
+/      function, must be added to the project. Samples are available in
+/      option/syscall.c.
 /
-/  The FF_FS_TIMEOUT defines timeout period in unit of O/S time tick.
-*/
+/  The FF_FS_TIMEOUT defines timeout period in unit of time tick.
+/  The FF_SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
+/  SemaphoreHandle_t and etc. A header file for O/S definitions needs to be
+/  included somewhere in the scope of ff.h. */
 
 
 

stm-firmware/include/reflow-controller/hw-version-detect.h

@@ -48,6 +48,7 @@
  */
 #define HW_REV_DETECT_PIN_HIGH (15U)
 
+
 /**
  * @brief PCB/Hardware Revision Type
  */

stm-firmware/include/reflow-controller/main-cycle-counter.h

@@ -30,16 +30,10 @@
 #include <stdint.h>
 
 /**
- * @brief Initialize the main cycle counter and reset to 0. This also enables the core cycle counter
+ * @brief Initialize/Reset the main cycle counter to 0.
  * This function can be called multiple times.
  */
-void main_and_core_cycle_counter_init(void);
-
-/**
- * @brief Reset the main cycle counter.
- * @note This does not reset the core cycle counter
- */
-void main_cycle_counter_reset(void);
+void main_cycle_counter_init(void);
 
 /**
  * @brief Increment the main cycle counter by 1
@@ -52,18 +46,6 @@ void main_cycle_counter_inc(void);
  */
 uint64_t main_cycle_counter_get(void);
 
-/**
- * @brief Reset the core cycle counter to 0
- */
-void core_cycle_counter_reset(void);
-
-/**
- * @brief Get the current value of the core cycle counter
- * 
- * @return uint32_t Counter value
- */
-uint32_t core_cycle_counter_get(void);
-
 #endif /* __MAIN_CYCLE_COUNTER_H__ */
 
 /** @} */

stm-firmware/include/reflow-controller/safety/flash-crc-struct.h

@@ -1,37 +0,0 @@
-/* Reflow Oven Controller
-*
-* Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
-*
-* This file is part of the Reflow Oven Controller Project.
-*
-* The reflow oven controller is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with the reflow oven controller project.
-* If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _SAFETY_FLASH_CRC_STRUCT_H_
-#define _SAFETY_FLASH_CRC_STRUCT_H_
-
-#include <stdint.h>
-
-struct flash_crcs {
-    uint32_t start_magic;
-    uint32_t crc_section_text;
-    uint32_t crc_section_data;
-    uint32_t crc_section_ccm_data;
-    uint32_t crc_section_vectors;
-    uint32_t end_magic;
-};
-
-extern const struct flash_crcs crcs_in_flash;
-
-#endif /* _SAFETY_FLASH_CRC_STRUCT_H_ */

stm-firmware/include/reflow-controller/safety/flash-crc.h

@@ -1,56 +0,0 @@
-/* Reflow Oven Controller
-*
-* Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
-*
-* This file is part of the Reflow Oven Controller Project.
-*
-* The reflow oven controller is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with the reflow oven controller project.
-* If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _SAFETY_FLASH_CRC_H_
-#define _SAFETY_FLASH_CRC_H_
-
-#include <stdint.h>
-
-enum flash_crc_section {
-    FLASH_CRC_VECTOR = 0,
-    FLASH_CRC_TEXT,
-    FLASH_CRC_DATA,
-    FLASH_CRC_CCMDATA,
-    N_FLASH_CRC,
-};
-
-/**
- * @brief Perform a CRC check of the flash memory and set appropriate flags
- * @return negative if internal error occured. Otherwise (independent from CRC check result) 0.
- * @note This function requires the safety controller (and CRC unit) to be set up before calling!
- */
-int flash_crc_trigger_check(void);
-
-/**
- * @brief Calculate CRC over flash section
- * @param sec Section to calculate CRC over
- * @param[out] crc_result Calculated CRC
- * @return negative if internal error occured. Otherwise (independent from CRC check result) 0.
- */
-int flash_crc_calc_section(enum flash_crc_section sec, uint32_t *crc_result);
-
-/**
- * @brief Get expected CRC value of a section
- * @param sec Section
- * @return Expected CRC
- */
-uint32_t flash_crc_get_expected_crc(enum flash_crc_section sec);
-
-#endif /* _SAFETY_FLASH_CRC_H_ */

stm-firmware/include/reflow-controller/safety/safety-config.h

@@ -27,15 +27,6 @@
 #ifndef __SAFETY_CONFIG_H__
 #define __SAFETY_CONFIG_H__
 
-/**
- * @brief Weights of error flags.
- */
-enum config_weight {
-    SAFETY_FLAG_CONFIG_WEIGHT_NONE = 0, /**< @brief This flag has no global error consequence, but might be respected by certain software modules. */
-    SAFETY_FLAG_CONFIG_WEIGHT_PID = 1, /**< @brief This flag will force a stop of the temperature PID controller */
-    SAFETY_FLAG_CONFIG_WEIGHT_PANIC = 2, /**< @brief This flag will trigger the panic mode */
-};
-
 /**
  * @brief Enum type representing safety flags.
  *
@@ -69,7 +60,6 @@ enum safety_flag {
 	ERR_FLAG_FLASH_CRC_DATA = (1<<20),
 	ERR_FLAG_CFG_CRC_MEAS_ADC = (1<<21),
 	ERR_FLAG_CFG_CRC_SAFETY_ADC = (1<<22),
-	ERR_FLAG_CFG_CRC_MISC = (1<<23),
 };
 
 /**
@@ -88,7 +78,6 @@ enum timing_monitor {
 enum crc_monitor {
 	ERR_CRC_MON_MEAS_ADC = 0,
 	ERR_CRC_MON_SAFETY_ADC,
-	ERR_CRC_MON_MISC,
 	N_ERR_CRC_MON
 };
 
@@ -126,15 +115,7 @@ enum analog_value_monitor {
 #define WATCHDOG_HALT_DEBUG (0)
 #endif
 
-/**
- * @brief Watchdog clock prescaler value
- */
-#define WATCHDOG_PRESCALER (16)
-
-/**
- * @brief Watchdog reload value
- */
-#define WATCHDOG_RELOAD_VALUE (2500)
+#define WATCHDOG_PRESCALER 16
 
 /**
  * @brief Minimum number of bytes that have to be free on the stack. If this is not the case, an error is detected
@@ -178,13 +159,7 @@ enum analog_value_monitor {
 #define SAFETY_CRC_MON_SAFETY_ADC_PW 0xA8DF2368
 
 /**
- * @brief Password for resetting ERR_CRC_MON_MISC
- * 
- */
-#define SAFETY_CRC_MON_MISC_PW 0x9A62E96A
-
-/**
- * @brief Default persistence of safety flags. These values are loaded into the safety tables on startup.
+ * @brief Default persistence of safety flags. These values are loaded into the safety tables on startup
  */
 #define SAFETY_CONFIG_DEFAULT_PERSIST	ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_MEAS_ADC_OFF, false), \
 					ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_MEAS_ADC_WATCHDOG, false), \
@@ -209,9 +184,8 @@ enum analog_value_monitor {
 					ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_FLASH_CRC_DATA, true), \
 					ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_CFG_CRC_MEAS_ADC, true), \
 					ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_CFG_CRC_SAFETY_ADC, true), \
-					ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_CFG_CRC_MISC, true),
 /**
- * @brief Default config weights of safety flags. These values are loaded into the safety tables on startup.
+ * @brief Default config weights of safety flags. These values are loaded into the safety tables on startup
  */
 #define SAFETY_CONFIG_DEFAULT_WEIGHTS 	ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_MEAS_ADC_OFF, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
 			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_MEAS_ADC_WATCHDOG, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
@@ -232,10 +206,9 @@ enum analog_value_monitor {
 			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_SAFETY_TAB_CORRUPT, SAFETY_FLAG_CONFIG_WEIGHT_PANIC), \
 			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_AMON_SUPPLY_VOLT, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
 			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_OVERTEMP, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
-			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_FLASH_CRC_CODE, SAFETY_FLAG_CONFIG_WEIGHT_PANIC), \
-			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_FLASH_CRC_DATA, SAFETY_FLAG_CONFIG_WEIGHT_PANIC), \
-			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_CFG_CRC_MEAS_ADC, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
-			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_CFG_CRC_SAFETY_ADC, SAFETY_FLAG_CONFIG_WEIGHT_PANIC), \
-			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_CFG_CRC_MISC, SAFETY_FLAG_CONFIG_WEIGHT_PANIC)			
+			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_FLASH_CRC_CODE, SAFETY_FLAG_CONFIG_WEIGHT_NONE), \
+			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_FLASH_CRC_DATA, SAFETY_FLAG_CONFIG_WEIGHT_NONE), \
+			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_CFG_CRC_MEAS_ADC, SAFETY_FLAG_CONFIG_WEIGHT_NONE), \
+			ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_CFG_CRC_SAFETY_ADC, SAFETY_FLAG_CONFIG_WEIGHT_NONE), \
 
 #endif /* __SAFETY_CONFIG_H__ */

stm-firmware/include/reflow-controller/safety/safety-controller.h

@@ -70,14 +70,14 @@ struct timing_monitor_info {
  * You have to call safety_controller_handle
  * If this function fails, it will hang, because errors in the safety controller are not recoverable
  */
-void safety_controller_init(void);
+void safety_controller_init();
 
 /**
  * @brief Handle the safety controller.
  * @note This function must be executed periodically in order to prevent the watchdog from resetting the firmware
- * @returns Worst flag weigth that is currently set.
+ * @return 0 if successful
  */
-enum config_weight safety_controller_handle(void);
+int safety_controller_handle();
 
 /**
  * @brief Report one or multiple errors to the safety controller
@@ -170,13 +170,13 @@ bool safety_controller_get_flags_by_mask(enum safety_flag mask);
  * @brief Get the count of error flags
  * @return Error flag count
  */
-uint32_t safety_controller_get_flag_count(void);
+uint32_t safety_controller_get_flag_count();
 
 /**
  * @brief Get the count of analog monitors
  * @return Analog monitor count
  */
-uint32_t safety_controller_get_analog_monitor_count(void);
+uint32_t safety_controller_get_analog_monitor_count();
 
 /**
  * @brief Get an error flag's name by its index.
@@ -267,6 +267,13 @@ int safety_controller_set_overtemp_limit(float over_temperature);
  */
 float safety_controller_get_overtemp_limit(void);
 
+/**
+ * @brief Perform a CRC check of the flash memory and set appropriate flags
+ * @return negative if internal error occured. Otherwise (independent from CRC check result) 0.
+ * @note This function requires the safety controller to be set up before!
+ */
+int safety_controller_trigger_flash_crc_check(void);
+
 /**
  * @brief Recalculate the CRC of a given CRC Monitor. This has to be done once the supervised registers update
  * @param mon Monitor to recalculate

stm-firmware/include/reflow-controller/safety/safety-memory.h

@@ -24,7 +24,6 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
-#include <reflow-controller/safety/safety-config.h>
 
 /** @addtogroup safety-memory
  * @{
@@ -132,6 +131,15 @@ enum config_override_entry_type {
 	SAFETY_MEMORY_CONFIG_OVERRIDE_PERSISTENCE = 2,
 };
 
+/**
+ * @brief Weights of error flags.
+ */
+enum config_weight {
+	SAFETY_FLAG_CONFIG_WEIGHT_NONE = 0, /**< @brief This flag has no global error consequence, but might be respected by certain software modules. */
+	SAFETY_FLAG_CONFIG_WEIGHT_PID = 1, /**< @brief This flag will force a stop of the temperature PID controller */
+	SAFETY_FLAG_CONFIG_WEIGHT_PANIC = 2, /**< @brief This flag will trigger the panic mode */
+};
+
 /**
  * @brief representation of a config override memory entry
  */

stm-firmware/include/reflow-controller/safety/watchdog.h

@@ -27,19 +27,11 @@
 
 /**
  * @brief Setup the watchdog for the safety controller
- *
- * The watchdog timeout can be calculated with:
- * \f[ t = \frac{(\mathrm{RELOAD_VAL} + 1)\cdot \mathrm{PRESCALER}}{32000 } s\f]
- *
- * Valid prescaler values are: 4, 8, 16, 32, 64, 128, 256.
- * @param prescaler Prescaler to use for the 32 KHz LSI clock
- * @param reload_value Reload value to reload the timer with when reset. 0 to 0xFFF
+ * @param Prescaler to use for the 32 KHz LSI clock
  * @return 0 if successful
- * @return -1 if prescaler is wrong
- * @return -2 if a reload value > 0xFFF is selected. 0xFFF will be used in this case
  * @note Once the watchdog is enabled, it cannot be turned off!
  */
-int watchdog_setup(uint16_t prescaler, uint16_t reload_value);
+int watchdog_setup(uint8_t prescaler);
 
 /**
  * @brief Reset watchdog counter

stm-firmware/include/reflow-controller/sd.h

@@ -1,42 +0,0 @@
-/* Reflow Oven Controller
- *
- * Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * GDSII-Converter is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
-
- #ifndef _SD_H_
- #define _SD_H_
-
-#include <stdbool.h>
-#include <fatfs/ff.h>
-
-/**
- * @brief Mount the SD card if available and not already mounted
- * @param fs Filesystem to mount to.
- * @return true if mounted, false if an error occured or the SD is not inserted and cannot be mounted
- */
-bool mount_sd_card_if_avail(FATFS *fs);
-
-/**
- * @brief Return whether an SD card is inserted and mounted
- * 
- * @return true SD inserted and mounted
- * @return false No SD inserted or not mounted
- */
-bool sd_card_is_mounted(void);
-
-#endif /* _SD_H_ */

stm-firmware/include/reflow-controller/settings/spi-eeprom.h

@@ -28,12 +28,12 @@
  * @brief Initialize the SPI for the eeprom.
  * @return 0 if succesful
  */
-int spi_eeprom_init(void);
+int spi_eeprom_init();
 
 /**
  * @brief Uninitialize the SPI EEPROM
  */
-void spi_eeprom_deinit(void);
+void spi_eeprom_deinit();
 
 /**
  * @brief Read from SPI EEPROM

stm-firmware/include/reflow-controller/version.h

@@ -1,29 +0,0 @@
-/* Reflow Oven Controller
- *
- * Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _VERSION_H_
-#define _VERSION_H_
-
-extern const char *version_git_version_string;
-extern const char *version_git_full_commit_string;
-extern const char *version_compile_date;
-extern const char *version_compile_time;
-
-#endif /* _VERSION_H_ */

stm-firmware/include/stm-periph/rng.h

@@ -33,7 +33,7 @@ enum random_number_error {
 
 void random_number_gen_init(bool int_enable);
 
-void random_number_gen_deinit(void);
+void random_number_gen_deinit();
 
 void random_number_gen_reset(bool int_en);
 

stm-firmware/include/stm-periph/unique-id.h

@@ -33,6 +33,4 @@ void stm_unique_id_get(uint32_t *high, uint32_t *mid, uint32_t *low);
 
 void stm_dev_rev_id_get(uint32_t *device_id, uint32_t *revision_id);
 
-void stm_cpuid_get(uint8_t *implementer, uint8_t *variant, uint16_t *part_no, uint8_t *rev);
-
 #endif /* __UNIQUE_ID_H__ */

stm-firmware/main-cycle-counter.c

@@ -25,7 +25,6 @@
 
 #include <reflow-controller/main-cycle-counter.h>
 #include <helper-macros/helper-macros.h>
-#include <stm32/stm32f4xx.h>
 
 /**
  * @brief Variable storing the main cycle counter.
@@ -34,22 +33,7 @@
  */
 static uint64_t IN_SECTION(.ccm.bss) main_cycle_counter;
 
-void main_and_core_cycle_counter_init(void)
-{
-	CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;	
-
-	/* Enable the core cycle counter if available on current processor */
-	if (!(DWT->CTRL & DWT_CTRL_NOCYCCNT_Msk)) {
-		/* Cycle counter is available. Enable */
-		DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
-	}
-
-	/* Reset the counters to 0 */
-	main_cycle_counter_reset();
-	core_cycle_counter_reset();
-}	
-
-void main_cycle_counter_reset(void)
+void main_cycle_counter_init(void)
 {
 	main_cycle_counter = 0ULL;
 }
@@ -64,14 +48,4 @@ uint64_t main_cycle_counter_get(void)
 	return main_cycle_counter;
 }
 
-void core_cycle_counter_reset(void)
-{
-	DWT->CYCCNT = 0UL;
-}
-
-uint32_t core_cycle_counter_get(void)
-{
-	return DWT->CYCCNT;
-}
-
 /** @} */

stm-firmware/main.c

@@ -23,7 +23,6 @@
  * @brief Main file for firmware
  */
 
-#include "reflow-controller/safety/safety-config.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -33,13 +32,13 @@
 #include <reflow-controller/systick.h>
 #include <reflow-controller/adc-meas.h>
 #include <reflow-controller/digio.h>
+#include "fatfs/shimatta_sdio_driver/shimatta_sdio.h"
 #include <stm-periph/stm32-gpio-macros.h>
 #include <stm-periph/rcc-manager.h>
 #include <stm-periph/uart.h>
 #include <reflow-controller/periph-config/shell-uart-config.h>
 #include <reflow-controller/oven-driver.h>
 #include <fatfs/ff.h>
-#include <reflow-controller/sd.h>
 #include <reflow-controller/ui/gui.h>
 #include <reflow-controller/ui/shell.h>
 #include <reflow-controller/ui/shell-uart.h>
@@ -89,6 +88,40 @@ static inline void uart_gpio_config(void)
 #endif
 }
 
+/**
+ * @brief Mount the SD card if available and not already mounted
+ * @param mounted The current mounting state of the SD card
+ * @return true if mounted, false if an error occured or the SD is not inserted and cannot be mounted
+ */
+static bool mount_sd_card_if_avail(bool mounted)
+{
+	FRESULT res;
+	static uint8_t IN_SECTION(.ccm.bss) inserted_counter = 0;
+
+	if (sdio_check_inserted() && mounted) {
+		memset(fs_ptr, 0, sizeof(FATFS));
+		sdio_stop_clk();
+		inserted_counter = 0;
+		return false;
+	}
+
+	if (!sdio_check_inserted() && inserted_counter < 255)
+		inserted_counter++;
+
+	if (!sdio_check_inserted() && !mounted && inserted_counter > 4) {
+		inserted_counter = 0;
+		res = f_mount(fs_ptr, "0:/", 1);
+		if (res == FR_OK) {
+			led_set(1, 1);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	return mounted;
+}
+
 /**
  * @brief Process the boot status structure in the safety (backup) RAM
  * Depending on the flags set there, this function will:
@@ -216,9 +249,6 @@ static inline void setup_system(void)
 
 	/** - Enable the ADC for PT1000 measurement */
 	adc_pt1000_setup_meas();
-
-	/** - Enable the misc CRC config monitor to supervise clock, systick and flash settings */
-	(void)safety_controller_set_crc_monitor(ERR_CRC_MON_MISC, SAFETY_CRC_MON_MISC_PW);
 }
 
 /**
@@ -256,7 +286,6 @@ int main(void)
 	shellmatta_handle_t shell_handle;
 	int menu_wait_request;
 	uint64_t quarter_sec_timestamp = 0ULL;
-	enum config_weight worst_safety_flag = SAFETY_FLAG_CONFIG_WEIGHT_NONE;
 
 	/** - Setup all the peripherals and external componets like LCD, EEPROM etc. and the safety controller */
 	setup_system();
@@ -272,8 +301,8 @@ int main(void)
 	/** - Print motd to shell */
 	shell_print_motd(shell_handle);
 
-	/** - Set the main cycle counter to 0 and activate the core cycle counter if available */
-	main_and_core_cycle_counter_init();
+	/** - Set the main cycle counter to 0 */
+	main_cycle_counter_init();
 
 	/** - Do a loop over the following */
 	while (1) {
@@ -283,9 +312,9 @@ int main(void)
 		 *  it is tried to load it from SD card.
 		 */
 		if (systick_ticks_have_passed(quarter_sec_timestamp, 250)) {
-			led_set(1u, 0);
+			led_set(1, 0);
 			sd_old = sd_card_mounted;
-			sd_card_mounted = mount_sd_card_if_avail(fs_ptr);
+			sd_card_mounted = mount_sd_card_if_avail(sd_card_mounted);
 
 			if (sd_card_mounted && !sd_old) {
 				adc_pt1000_get_resistance_calibration(NULL, NULL, &cal_active);
@@ -296,14 +325,6 @@ int main(void)
 				}
 			}
 
-			/* Check if any flags are present, that disable the PID controller. Blink
-			 * LED 0 in this case
-			 */
-			if (worst_safety_flag >= SAFETY_FLAG_CONFIG_WEIGHT_PID)
-				led_set(0u, led_get(0u) ? 0 : 1);
-			else
-				led_set(0u, 0);
-
 			quarter_sec_timestamp = systick_get_global_tick();
 		}
 
@@ -317,7 +338,7 @@ int main(void)
 		temp_profile_executer_handle();
 
 		/** - Handle the safety controller. This must be called! Otherwise a watchdog reset will occur */
-		worst_safety_flag = safety_controller_handle();
+		safety_controller_handle();
 
 		/** - If the Oven PID controller is running, we handle its sample function */
 		if (oven_pid_get_status() == OVEN_PID_RUNNING)

stm-firmware/safety/fault.c

@@ -78,6 +78,5 @@ void panic_mode(void)
 	}
 
 	/* Let the watchdog do the rest */
-	while (1)
-		;
+	while (1);
 }

stm-firmware/safety/flash-crc-struct.c

@@ -1,31 +0,0 @@
-/* Reflow Oven Controller
-*
-* Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
-*
-* This file is part of the Reflow Oven Controller Project.
-*
-* The reflow oven controller is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with the reflow oven controller project.
-* If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <reflow-controller/safety/flash-crc-struct.h>
-#include <helper-macros/helper-macros.h>
-
-const struct flash_crcs IN_SECTION(.flashcrc) crcs_in_flash = {
-	.start_magic = 0xA8BE53F9UL,
-	.crc_section_ccm_data = 0UL,
-	.crc_section_text = 0UL,
-	.crc_section_data = 0UL,
-	.crc_section_vectors = 0UL,
-	.end_magic = 0xFFA582FFUL,
-};

stm-firmware/safety/flash-crc.c

@@ -1,152 +0,0 @@
-/* Reflow Oven Controller
-*
-* Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
-*
-* This file is part of the Reflow Oven Controller Project.
-*
-* The reflow oven controller is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with the reflow oven controller project.
-* If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <reflow-controller/safety/flash-crc.h>
-#include <reflow-controller/safety/flash-crc-struct.h>
-#include <reflow-controller/safety/safety-controller.h>
-#include <stm-periph/crc-unit.h>
-
-extern const uint32_t __ld_vectors_start;
-extern const uint32_t __ld_vectors_end;
-extern const uint32_t __ld_text_start;
-extern const uint32_t __ld_text_end;
-
-extern const uint32_t __ld_sdata_ccm;
-extern const uint32_t __ld_edata_ccm;
-extern const uint32_t __ld_load_ccm_data;
-
-extern const uint32_t __ld_sdata;
-extern const uint32_t __ld_edata;
-extern const uint32_t __ld_load_data;
-
-
-int flash_crc_trigger_check(void)
-{
-	int ret = -1;
-	int res;
-	int any_err = 0;
-	uint32_t crc;
-
-	/* Perform CRC check over vector table */
-	res = flash_crc_calc_section(FLASH_CRC_VECTOR, &crc);
-	if (res || crc != flash_crc_get_expected_crc(FLASH_CRC_VECTOR))
-		safety_controller_report_error(ERR_FLAG_FLASH_CRC_CODE);
-	any_err |= res;
-
-	/* Perform CRC check over text section */
-	res = flash_crc_calc_section(FLASH_CRC_TEXT, &crc);
-	if (res || crc != flash_crc_get_expected_crc(FLASH_CRC_TEXT))
-		safety_controller_report_error(ERR_FLAG_FLASH_CRC_CODE);
-	any_err |= res;
-
-	/* Perform CRC check over data section */
-	res = flash_crc_calc_section(FLASH_CRC_DATA, &crc);
-	if (res || crc != flash_crc_get_expected_crc(FLASH_CRC_DATA))
-		safety_controller_report_error(ERR_FLAG_FLASH_CRC_DATA);
-	any_err |= res;
-
-	/* Perform CRC check over ccm data section */
-	res = flash_crc_calc_section(FLASH_CRC_CCMDATA, &crc);
-	if (res || crc != flash_crc_get_expected_crc(FLASH_CRC_CCMDATA))
-		safety_controller_report_error(ERR_FLAG_FLASH_CRC_DATA);
-	any_err |= res;
-
-	if (!any_err)
-		ret = 0;
-
-	return ret;
-}
-
-int flash_crc_calc_section(enum flash_crc_section sec, uint32_t *crc_result)
-{
-	uint32_t len;
-	const uint32_t *startptr;
-	const uint32_t *endptr;
-	const uint32_t *load_addr = NULL;
-
-	if (!crc_result)
-		return -1002;
-
-	switch (sec) {
-	case FLASH_CRC_VECTOR:
-		startptr = &__ld_vectors_start;
-		endptr = &__ld_vectors_end;
-		break;
-	case FLASH_CRC_TEXT:
-		startptr = &__ld_text_start;
-		endptr = &__ld_text_end;
-		break;
-	case FLASH_CRC_DATA:
-		startptr = &__ld_sdata;
-		endptr = &__ld_edata;
-		load_addr = &__ld_load_data;
-		break;
-	case FLASH_CRC_CCMDATA:
-		startptr = &__ld_sdata_ccm;
-		endptr = &__ld_edata_ccm;
-		load_addr = &__ld_load_ccm_data;
-		break;
-	default:
-		return -1001;
-	}
-
-	len = (uint32_t)((void *)endptr - (void *)startptr);
-	if (!load_addr)
-		load_addr = startptr;
-
-	/* Not a multiple of 32bit words long. Cannot calculate CRC in this case! */
-	if (len % 4)
-		return -1;
-
-	/* Calculate word count */
-	len /= 4;
-
-	/* Reset CRC and calculate over data range */
-	crc_unit_reset();
-	crc_unit_input_array(load_addr, len);
-	*crc_result = crc_unit_get_crc();
-
-	return 0;
-}
-
-uint32_t flash_crc_get_expected_crc(enum flash_crc_section sec)
-{
-	uint32_t crc;
-
-	switch (sec) {
-	case FLASH_CRC_VECTOR:
-		crc = crcs_in_flash.crc_section_vectors;
-		break;
-	case FLASH_CRC_TEXT:
-		crc = crcs_in_flash.crc_section_text;
-		break;
-	case FLASH_CRC_DATA:
-		crc = crcs_in_flash.crc_section_data;
-		break;
-	case FLASH_CRC_CCMDATA:
-		crc = crcs_in_flash.crc_section_ccm_data;
-		break;
-	default:
-		crc = 0xFFFFFFFFul;
-		break;
-	}
-
-	return crc;
-}

stm-firmware/safety/safety-adc.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 /**
  * @addtogroup safety-adc
@@ -60,8 +60,7 @@ void safety_adc_init(void)
 	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(RCC_AHB1ENR_DMA2EN));
 
 	if (hw_rev != HW_REV_V1_2) {
-		rcc_manager_enable_clock(&RCC->AHB1ENR,
-					 BITMASK_TO_BITNO(SAFETY_ADC_SUPPLY_VOLTAGE_MONITOR_PORT_RCC_MASK));
+		rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(SAFETY_ADC_SUPPLY_VOLTAGE_MONITOR_PORT_RCC_MASK));
 		SAFETY_ADC_SUPPLY_VOLTAGE_MONITOR_PORT->MODER &= MODER_DELETE(SAFETY_ADC_SUPPLY_VOLTAGE_MONITOR_PIN);
 		SAFETY_ADC_SUPPLY_VOLTAGE_MONITOR_PORT->MODER |= ANALOG(SAFETY_ADC_SUPPLY_VOLTAGE_MONITOR_PIN);
 	}
@@ -73,7 +72,7 @@ void safety_adc_init(void)
 	SAFETY_ADC_ADC_PERIPHERAL->SMPR1 |= ADC_SMPR1_SMP17 | ADC_SMPR1_SMP16 | ADC_SMPR1_SMP15;
 
 	/* Standard sequence. Measure all channels in one sequence */
-	SAFETY_ADC_ADC_PERIPHERAL->SQR1 = (SAFETY_ADC_NUM_OF_CHANNELS - 1) << 20;
+	SAFETY_ADC_ADC_PERIPHERAL->SQR1 = (SAFETY_ADC_NUM_OF_CHANNELS - 1) << 20 ;
 	SAFETY_ADC_ADC_PERIPHERAL->SQR2 = 0UL;
 	SAFETY_ADC_ADC_PERIPHERAL->SQR3 = 0UL;
 
@@ -98,8 +97,7 @@ void safety_adc_init(void)
 	DMA2_Stream4->PAR = (uint32_t)&SAFETY_ADC_ADC_PERIPHERAL->DR;
 	DMA2_Stream4->M0AR = (uint32_t)safety_adc_conversions;
 	DMA2_Stream4->NDTR = SAFETY_ADC_NUM_OF_CHANNELS;
-	DMA2_Stream4->CR = DMA_SxCR_PL_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PSIZE_0 | DMA_SxCR_MINC | DMA_SxCR_CIRC |
-			DMA_SxCR_TCIE | DMA_SxCR_EN;
+	DMA2_Stream4->CR = DMA_SxCR_PL_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PSIZE_0 | DMA_SxCR_MINC | DMA_SxCR_CIRC | DMA_SxCR_TCIE | DMA_SxCR_EN;
 	NVIC_EnableIRQ(DMA2_Stream4_IRQn);
 
 	/* Enable ADC */
@@ -177,7 +175,7 @@ void safety_adc_trigger_meas(void)
 	safety_adc_triggered = 1;
 }
 
-void DMA2_Stream4_IRQHandler(void)
+void DMA2_Stream4_IRQHandler()
 {
 	uint32_t hisr;
 

stm-firmware/safety/safety-controller.c

@@ -1,29 +1,28 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 /**
  * @addtogroup safety-controller
  * @{
  */
 
-#include "stm32/stm32f407xx.h"
 #include <reflow-controller/safety/safety-controller.h>
 #include <reflow-controller/safety/safety-config.h>
 #include <reflow-controller/safety/watchdog.h>
@@ -44,7 +43,6 @@
 #include <stm-periph/rcc-manager.h>
 #include <reflow-controller/temp-converter.h>
 #include <reflow-controller/adc-meas.h>
-#include <reflow-controller/safety/flash-crc.h>
 #include <reflow-controller/periph-config/safety-adc-hwcfg.h>
 
 /**
@@ -156,6 +154,15 @@ struct overtemp_config {
 	uint32_t crc;
 };
 
+struct flash_crcs {
+	uint32_t start_magic;
+	uint32_t crc_section_text;
+	uint32_t crc_section_data;
+	uint32_t crc_section_ccm_data;
+	uint32_t crc_section_vectors;
+	uint32_t end_magic;
+};
+
 struct crc_monitor_register {
 	const volatile void *reg_addr;
 	uint32_t mask;
@@ -164,15 +171,9 @@ struct crc_monitor_register {
 
 #define CRC_MON_REGISTER_ENTRY(_addr, _mask, _size) {.reg_addr = &(_addr), .mask = (_mask), .size = (_size)}
 
-/**
- * @brief Sentinel Element for crc monitor register list
- * 
- */
-#define CRC_MON_REGISTER_SENTINEL {.reg_addr = NULL, .mask = 0, .size = 0}
-
 struct crc_mon {
 	/**
-	 * @brief Array of registers to monitor. Terminated by NULL sentinel @ref CRC_MON_REGISTER_SENTINEL
+	 * @brief Array of registers to monitor. Terminated by NULL sentinel!
 	 */
 	const struct crc_monitor_register *registers;
 	const enum crc_monitor monitor;
@@ -211,7 +212,6 @@ static volatile struct error_flag IN_SECTION(.ccm.data) flags[] = {
 	ERR_FLAG_ENTRY(ERR_FLAG_FLASH_CRC_DATA),
 	ERR_FLAG_ENTRY(ERR_FLAG_CFG_CRC_MEAS_ADC),
 	ERR_FLAG_ENTRY(ERR_FLAG_CFG_CRC_SAFETY_ADC),
-	ERR_FLAG_ENTRY(ERR_FLAG_CFG_CRC_MISC),
 };
 
 /**
@@ -298,8 +298,8 @@ static const struct crc_monitor_register meas_adc_crc_regs[] = {
 			       ADC_SQR2_SQ12 | ADC_SQR2_SQ11 | ADC_SQR2_SQ10 | ADC_SQR2_SQ9 |
 			       ADC_SQR2_SQ8 | ADC_SQR2_SQ7, 4),
 	CRC_MON_REGISTER_ENTRY(ADC_PT1000_PERIPH->SQR3, ADC_SQR3_SQ6 | ADC_SQR3_SQ5 | ADC_SQR3_SQ4 |
-			       ADC_SQR3_SQ3 | ADC_SQR3_SQ2 | ADC_SQR3_SQ1, 4),
-	CRC_MON_REGISTER_SENTINEL
+			       ADC_SQR3_SQ3| ADC_SQR3_SQ2 | ADC_SQR3_SQ1, 4),
+	{NULL, 0, 0}
 };
 
 static const struct crc_monitor_register safety_adc_crc_regs[] = {
@@ -314,28 +314,12 @@ static const struct crc_monitor_register safety_adc_crc_regs[] = {
 			       ADC_SQR2_SQ12 | ADC_SQR2_SQ11 | ADC_SQR2_SQ10 | ADC_SQR2_SQ9 |
 			       ADC_SQR2_SQ8 | ADC_SQR2_SQ7, 4),
 	CRC_MON_REGISTER_ENTRY(SAFETY_ADC_ADC_PERIPHERAL->SQR3, ADC_SQR3_SQ6 | ADC_SQR3_SQ5 | ADC_SQR3_SQ4 |
-			       ADC_SQR3_SQ3 | ADC_SQR3_SQ2 | ADC_SQR3_SQ1, 4),
-	CRC_MON_REGISTER_ENTRY(RCC->APB2ENR, SAFETY_ADC_ADC_RCC_MASK, 4),
-	CRC_MON_REGISTER_SENTINEL
+			       ADC_SQR3_SQ3| ADC_SQR3_SQ2 | ADC_SQR3_SQ1, 4),
+	{NULL, 0, 0}
 };
 
-static const struct crc_monitor_register misc_config_crc_regs[] = {
-	/* Check clock tree settings */
-	CRC_MON_REGISTER_ENTRY(RCC->CR, RCC_CR_PLLON | RCC_CR_HSEON | RCC_CR_PLLI2SON | RCC_CR_HSION, 4),
-    CRC_MON_REGISTER_ENTRY(RCC->CSR, RCC_CSR_LSION, 4),
-	CRC_MON_REGISTER_ENTRY(RCC->CFGR, RCC_CFGR_SWS | RCC_CFGR_HPRE | RCC_CFGR_PPRE1 | RCC_CFGR_PPRE2, 4),
-	CRC_MON_REGISTER_ENTRY(RCC->PLLCFGR, RCC_PLLCFGR_PLLM | RCC_PLLCFGR_PLLQ | RCC_PLLCFGR_PLLSRC | RCC_PLLCFGR_PLLP | RCC_PLLCFGR_PLLN | RCC_PLLCFGR_PLLM , 4),
-	/* Check Flash settings */
-	CRC_MON_REGISTER_ENTRY(FLASH->ACR, FLASH_ACR_LATENCY | FLASH_ACR_DCEN | FLASH_ACR_ICEN | FLASH_ACR_PRFTEN, 4),
-	/* Check vector table offset */
-	CRC_MON_REGISTER_ENTRY(SCB->VTOR, 0xFFFFFFFF, 4),
-	/* Check system tick configuration */
-	CRC_MON_REGISTER_ENTRY(SysTick->CTRL, SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk, 4),
-	CRC_MON_REGISTER_ENTRY(SysTick->LOAD, 0xFFFFFFFF, 4),
-	CRC_MON_REGISTER_SENTINEL
-};
-
-static struct crc_mon IN_SECTION(.ccm.data) crc_monitors[] = {
+static struct crc_mon IN_SECTION(.ccm.data) crc_monitors[] =
+{
 	{
 		.registers = meas_adc_crc_regs,
 		.monitor = ERR_CRC_MON_MEAS_ADC,
@@ -356,16 +340,6 @@ static struct crc_mon IN_SECTION(.ccm.data) crc_monitors[] = {
 		.last_crc = 0UL,
 		.active = false,
 	},
-	{
-		.registers = misc_config_crc_regs,
-		.monitor = ERR_CRC_MON_MISC,
-		.pw = SAFETY_CRC_MON_MISC_PW,
-		.flag_to_set = ERR_FLAG_CFG_CRC_MISC,
-		.expected_crc = 0UL,
-		.expected_crc_inv = ~0UL,
-		.last_crc = 0UL,
-		.active = false,
-	}
 };
 
 /**
@@ -386,22 +360,16 @@ static void set_overtemp_config(float over_temperature)
 	safety_controller_overtemp_config.crc_dummy_seed = 0xA4F5C7E6UL;
 	safety_controller_overtemp_config.overtemp_deg_celsius = over_temperature;
 	safety_controller_overtemp_config.overtemp_equiv_resistance = resistance;
-	crc_unit_input_array((const uint32_t *)&safety_controller_overtemp_config,
-			     wordsize_of(struct overtemp_config) - 1);
+	crc_unit_input_array((const uint32_t *)&safety_controller_overtemp_config, wordsize_of(struct overtemp_config) - 1);
 	safety_controller_overtemp_config.crc = crc_unit_get_crc();
 }
 
-/**
- * @brief Check the overtemperature config structure's CRC
- * @return true if check failed. false if CRC check successful
- */
 static bool over_temperature_config_check(void)
 {
 	if (safety_controller_overtemp_config.crc_dummy_seed != 0xA4F5C7E6UL)
 		return true;
 	crc_unit_reset();
-	crc_unit_input_array((const uint32_t *)&safety_controller_overtemp_config,
-			     wordsize_of(struct overtemp_config) - 1);
+	crc_unit_input_array((const uint32_t *)&safety_controller_overtemp_config, wordsize_of(struct overtemp_config) - 1);
 	if (crc_unit_get_crc() != safety_controller_overtemp_config.crc)
 		return true;
 
@@ -474,7 +442,7 @@ static int flag_weight_table_crc_check(void)
 static int flag_persistence_table_crc_check(void)
 {
 	crc_unit_reset();
-	crc_unit_input_array((uint32_t *)flag_persistencies, wordsize_of(flag_persistencies));
+	crc_unit_input_array((uint32_t*)flag_persistencies, wordsize_of(flag_persistencies));
 
 	if (crc_unit_get_crc() != flag_persistencies_crc)
 		return -1;
@@ -551,8 +519,9 @@ static int safety_controller_check_crc_monitors(void)
 
 		if (crc_monitor_calculate_crc(mon->registers, &crc))
 			return -1;
-		if (mon->expected_crc != crc || ~mon->expected_crc_inv != crc)
+		if (mon->expected_crc != crc || ~mon->expected_crc_inv != crc) {
 			safety_controller_report_error(mon->flag_to_set);
+		}
 		mon->last_crc = crc;
 	}
 
@@ -579,7 +548,7 @@ static void init_safety_flag_weight_table_from_default(void)
 	}
 
 	crc_unit_reset();
-	crc_unit_input_array((uint32_t *)flag_weights, wordsize_of(flag_weights));
+	crc_unit_input_array((uint32_t*)flag_weights, wordsize_of(flag_weights));
 	flag_weight_crc = crc_unit_get_crc();
 }
 
@@ -639,14 +608,16 @@ static void apply_config_overrides(void)
 		case SAFETY_MEMORY_CONFIG_OVERRIDE_WEIGHT:
 			flag_enum = flag_no_to_flag_enum(override.entry.weight_override.flag);
 			flag = find_error_flag(flag_enum);
-			if (flag && flag->weight)
+			if (flag && flag->weight) {
 				flag->weight->weight = override.entry.weight_override.weight;
+			}
 			break;
 		case SAFETY_MEMORY_CONFIG_OVERRIDE_PERSISTENCE:
 			flag_enum = flag_no_to_flag_enum(override.entry.persistence_override.flag);
 			flag = find_error_flag(flag_enum);
-			if (flag && flag->persistence)
+			if (flag && flag->persistence) {
 				flag->persistence->persistence = override.entry.persistence_override.persistence;
+			}
 			break;
 		default:
 			continue;
@@ -658,7 +629,7 @@ static void apply_config_overrides(void)
 	crc_unit_input_array((uint32_t *)flag_persistencies, wordsize_of(flag_persistencies));
 	flag_persistencies_crc = crc_unit_get_crc();
 	crc_unit_reset();
-	crc_unit_input_array((uint32_t *)flag_weights, wordsize_of(flag_weights));
+	crc_unit_input_array((uint32_t*)flag_weights, wordsize_of(flag_weights));
 	flag_weight_crc = crc_unit_get_crc();
 }
 
@@ -676,10 +647,11 @@ static bool error_flag_get_status(const volatile struct error_flag *flag)
 	if (!flag)
 		return true;
 
-	if (flag->error_state == flag->error_state_inv)
+	if (flag->error_state == flag->error_state_inv) {
 		return true;
-	else
+	} else {
 		return flag->error_state;
+	}
 }
 
 /**
@@ -721,7 +693,7 @@ static volatile struct timing_mon *find_timing_mon(enum timing_monitor mon)
 /**
  * @brief Check the active timing monitors and set the appropriate flags in case of an error.
  */
-static void safety_controller_process_active_timing_mons(void)
+static void safety_controller_process_active_timing_mons()
 {
 	uint32_t i;
 	volatile struct timing_mon *current_mon;
@@ -744,8 +716,7 @@ static void safety_controller_process_active_timing_mons(void)
  * Process the analog and timing monitors and set the relevant flags in case of a monitor outside its limits.
  * Furthermore, the PT1000 resistance is checked for overtemperature
  *
- * The checking of the analog monitors will only be armed after a startup delay of 1000 ms to
- * allow the values to stabilize.
+ * The checking of the analog monitors will only be armed after a startup delay of 1000 ms to allow the values to stabilize.
  */
 static void safety_controller_process_monitor_checks(void)
 {
@@ -760,18 +731,21 @@ static void safety_controller_process_monitor_checks(void)
 
 	if (startup_completed) {
 		analog_mon_count = safety_controller_get_analog_monitor_count();
-		for (idx = 0; idx < analog_mon_count; idx++)
+		for (idx = 0; idx < analog_mon_count; idx++) {
 			if (safety_controller_get_analog_mon_by_index(idx, &amon_info)) {
 				panic_mode();
+			}
 
-			if (amon_info.status != ANALOG_MONITOR_OK)
+			if (amon_info.status != ANALOG_MONITOR_OK) {
 				safety_controller_report_error(amon_info.associated_flag);
 			}
 		}
+	}
 
 	adc_pt1000_get_current_resistance(&pt1000_val);
-	if (pt1000_val > safety_controller_overtemp_config.overtemp_equiv_resistance)
+	if (pt1000_val > safety_controller_overtemp_config.overtemp_equiv_resistance) {
 		safety_controller_report_error(ERR_FLAG_OVERTEMP);
+	}
 
 	(void)safety_controller_check_crc_monitors();
 
@@ -846,9 +820,10 @@ void safety_controller_report_timing(enum timing_monitor monitor)
 	tim = find_timing_mon(monitor);
 	if (tim) {
 		if (tim->enabled) {
-			if (!systick_ticks_have_passed(tim->last, tim->min_delta) && tim->min_delta > 0U)
+			if (!systick_ticks_have_passed(tim->last, tim->min_delta) && tim->min_delta > 0U) {
 				safety_controller_report_error(tim->associated_flag);
 			}
+		}
 
 		tim->calculated_delta = timestamp - tim->last;
 		tim->last = timestamp;
@@ -895,9 +870,10 @@ static int get_safety_flags_from_error_mem(enum safety_flag *flags)
 
 	for (idx = 0; idx < count; idx++) {
 		res = safety_memory_get_error_entry(idx, &entry);
-		if (entry.type == SAFETY_MEMORY_ERR_ENTRY_FLAG)
+		if (entry.type == SAFETY_MEMORY_ERR_ENTRY_FLAG) {
 			return_flags |= flag_no_to_flag_enum(entry.flag_num);
 		}
+	}
 
 	*flags = return_flags;
 	return 0;
@@ -908,12 +884,11 @@ static int get_safety_flags_from_error_mem(enum safety_flag *flags)
  *
  * The external harware watchdog has to be periodically reset or it will reset hte controller.
  * Because debugging is not possible, when the watchdog is active, it is only activated, if the application is
- * compiled in release mode. Any interruption of the main programm will then trigger the internal and/or
- * the external watchdog.
+ * compiled in release mode. Any interruption of the main programm will then trigger the internal and/or the external watchdog.
  *
  * @note When enabled, execute the @ref external_watchdog_toggle function to reset the external watchdog.
  */
-static void safety_controller_init_external_watchdog(void)
+static void safety_controller_init_external_watchdog()
 {
 	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(SAFETY_EXT_WATCHDOG_RCC_MASK));
 	SAFETY_EXT_WATCHDOG_PORT->MODER &= MODER_DELETE(SAFETY_EXT_WATCHDOG_PIN);
@@ -924,7 +899,7 @@ static void safety_controller_init_external_watchdog(void)
 	__DSB();
 }
 
-void safety_controller_init(void)
+void safety_controller_init()
 {
 	enum safety_memory_state found_memory_state;
 	enum safety_flag flags_in_err_mem = ERR_FLAG_NO_FLAG;
@@ -941,7 +916,7 @@ void safety_controller_init(void)
 	/* This is usually done by the safety memory already. But, since this module also uses the CRC... */
 	crc_unit_init();
 
-	flash_crc_trigger_check();
+	safety_controller_trigger_flash_crc_check();
 	stack_check_init_corruption_detect_area();
 
 	hw_rev = get_pcb_hardware_version();
@@ -973,7 +948,7 @@ void safety_controller_init(void)
 						MEAS_ADC_SAFETY_FLAG_KEY);
 
 	safety_adc_init();
-	(void)watchdog_setup(WATCHDOG_PRESCALER, WATCHDOG_RELOAD_VALUE);
+	watchdog_setup(WATCHDOG_PRESCALER);
 
 	if (rcc_manager_get_reset_cause(false) & RCC_RESET_SOURCE_IWDG)
 		safety_controller_report_error(ERR_FLAG_WTCHDG_FIRED);
@@ -992,7 +967,7 @@ void safety_controller_init(void)
  * 1) Checking the remaining free space at the moment between stack pointer and top of heap.
  * 2) Checking The CRC of the corruption detect area between heap and stack
  */
-static void safety_controller_check_stack(void)
+static void safety_controller_check_stack()
 {
 	int32_t free_stack;
 
@@ -1000,17 +975,18 @@ static void safety_controller_check_stack(void)
 	if (free_stack < SAFETY_MIN_STACK_FREE)
 		safety_controller_report_error(ERR_FLAG_STACK);
 
-	if (stack_check_corruption_detect_area())
+	if (stack_check_corruption_detect_area()) {
 		safety_controller_report_error(ERR_FLAG_STACK);
+	}
 }
 
 /**
  * @brief Handle the Safety ADC
  *
  * This function handles the safety ADC.
- * If the safety ADC is not executing a measurment and the time since the last measurement has
- * passed @ref SAFETY_CONTROLLER_ADC_DELAY_MS, the safety ADC is retriggered and will automatically perform a
- * measurement on all of its channels.
+ * If the safety ADC ius not executing a measurment and the time since the last measurement has
+ * passed @ref SAFETY_CONTROLLER_ADC_DELAY_MS, the safety ADC is retriggered and will automatically perform a measurement
+ * on all of its channels.
  * When called again, this function will retrieve the data from the safety ADC and  converts it into the
  * appropriate analog values for the analog value monitors.
  *
@@ -1019,7 +995,7 @@ static void safety_controller_check_stack(void)
  *
  * The channels, the ssafety ADC will convert is defined in its header file using the define @ref SAFETY_ADC_CHANNELS.
  */
-static void safety_controller_handle_safety_adc(void)
+static void safety_controller_handle_safety_adc()
 {
 	static uint64_t last_result_timestamp = 0;
 	const uint16_t *channels;
@@ -1090,9 +1066,10 @@ static void safety_controller_handle_memory_checks(void)
 		/* Check the safety memory */
 		if (safety_memory_check()) {
 			(void)safety_memory_reinit(&found_state);
-			if (found_state != SAFETY_MEMORY_INIT_VALID_MEMORY)
+			if (found_state != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 				safety_controller_report_error(ERR_FLAG_SAFETY_MEM_CORRUPT);
 			}
+		}
 
 		/* If flag weight table is broken, reinit to default and set flag */
 		if (flag_weight_table_crc_check()) {
@@ -1101,7 +1078,7 @@ static void safety_controller_handle_memory_checks(void)
 		}
 
 		/* If persistence table is broken, reinit to default and set flag */
-		if (flag_persistence_table_crc_check()) {
+		if(flag_persistence_table_crc_check()) {
 			safety_controller_report_error(ERR_FLAG_SAFETY_TAB_CORRUPT);
 			init_safety_flag_persistencies_from_default();
 		}
@@ -1120,7 +1097,7 @@ static void safety_controller_handle_memory_checks(void)
  * If the systick stays constant for more than 1000 calls of this function,
  * the @ref ERR_FLAG_SYSTICK flag is set.
  */
-static void safety_controller_do_systick_checking(void)
+static void safety_controller_do_systick_checking()
 {
 	static uint64_t last_systick;
 	static uint32_t same_systick_cnt = 0UL;
@@ -1144,29 +1121,22 @@ static void safety_controller_do_systick_checking(void)
  * is set, the appropriate action defined by the flag weight is executed.
  * @note If no flag weigth is present for a given error flag, it is treated as the most critical category
  * (@ref SAFETY_FLAG_CONFIG_WEIGHT_PANIC)
- *
- * @returns Worst config weight set
  */
-static enum config_weight safety_controller_handle_weighted_flags(void)
+static void safety_controller_handle_weighted_flags()
 {
 	uint32_t flag_index;
 	volatile struct error_flag *current_flag;
 	enum config_weight flag_weigth;
-	enum config_weight worst = SAFETY_FLAG_CONFIG_WEIGHT_NONE;
 
 	for (flag_index = 0u; flag_index < COUNT_OF(flags); flag_index++) {
 		current_flag = &flags[flag_index];
 
 		/* Continue if this flag is not set */
-		if (!error_flag_get_status(current_flag))
+		if (!error_flag_get_status(current_flag)) {
 			continue;
+		}
 
 		flag_weigth = get_flag_weight(current_flag);
-
-		/* Override the worst flag weigt set, if it is worse than the previous ones */
-		if (flag_weigth > worst)
-			worst = flag_weigth;
-
 		switch (flag_weigth) {
 		case SAFETY_FLAG_CONFIG_WEIGHT_NONE:
 			break;
@@ -1182,20 +1152,18 @@ static enum config_weight safety_controller_handle_weighted_flags(void)
 		}
 
 	}
-
-	return worst;
 }
 
 #ifndef DEBUGBUILD
-static void external_watchdog_toggle(void)
+static void external_watchdog_toggle()
 {
 	SAFETY_EXT_WATCHDOG_PORT->ODR ^= (1<<SAFETY_EXT_WATCHDOG_PIN);
 }
 #endif
 
-enum config_weight safety_controller_handle(void)
+int safety_controller_handle()
 {
-	enum config_weight worst_weight_set;
+	int ret = 0;
 #ifndef DEBUGBUILD
 	static uint32_t watchdog_counter = 0UL;
 #endif
@@ -1205,10 +1173,9 @@ enum config_weight safety_controller_handle(void)
 	safety_controller_handle_memory_checks();
 	safety_controller_do_systick_checking();
 	safety_controller_process_monitor_checks();
-	worst_weight_set = safety_controller_handle_weighted_flags();
+	safety_controller_handle_weighted_flags();
 
-	/* Ignore error here. Will trigger restart anyway */
-	(void)watchdog_ack(WATCHDOG_MAGIC_KEY);
+	ret |= watchdog_ack(WATCHDOG_MAGIC_KEY);
 
 #ifndef DEBUGBUILD
 	if (get_pcb_hardware_version() != HW_REV_V1_2) {
@@ -1219,8 +1186,7 @@ enum config_weight safety_controller_handle(void)
 		}
 	}
 #endif
-
-	return worst_weight_set;
+	return (ret ? -1 : 0);
 }
 
 int safety_controller_enable_timing_mon(enum timing_monitor monitor, bool enable)
@@ -1307,8 +1273,9 @@ int safety_controller_ack_flag_with_key(enum safety_flag flag, uint32_t key)
 	int ret = -1;
 	volatile struct error_flag *found_flag;
 
-	if (!is_power_of_two(flag))
+	if (!is_power_of_two(flag)) {
 		return -1001;
+	}
 
 	found_flag = find_error_flag(flag);
 	if (found_flag) {
@@ -1339,17 +1306,17 @@ bool safety_controller_get_flags_by_mask(enum safety_flag mask)
 	return ret;
 }
 
-uint32_t safety_controller_get_flag_count(void)
+uint32_t safety_controller_get_flag_count()
 {
 	return COUNT_OF(flags);
 }
 
-uint32_t safety_controller_get_analog_monitor_count(void)
+uint32_t safety_controller_get_analog_monitor_count()
 {
 	return COUNT_OF(analog_mons);
 }
 
-uint32_t safety_controller_get_timing_monitor_count(void)
+uint32_t safety_controller_get_timing_monitor_count()
 {
 	return COUNT_OF(timings);
 }
@@ -1456,8 +1423,9 @@ int safety_controller_get_timing_mon_by_index(uint32_t index, struct timing_moni
 	if (!info)
 		return -1002;
 
-	if (index >= COUNT_OF(timings))
+	if (index >= COUNT_OF(timings)) {
 		return -1001;
+	}
 
 	mon = &timings[index];
 
@@ -1481,6 +1449,99 @@ float safety_controller_get_overtemp_limit(void)
 	return safety_controller_overtemp_config.overtemp_deg_celsius;
 }
 
+extern const uint32_t __ld_vectors_start;
+extern const uint32_t __ld_vectors_end;
+extern const uint32_t __ld_text_start;
+extern const uint32_t __ld_text_end;
+
+extern const uint32_t __ld_sdata_ccm;
+extern const uint32_t __ld_edata_ccm;
+extern const uint32_t __ld_load_ccm_data;
+
+extern const uint32_t __ld_sdata;
+extern const uint32_t __ld_edata;
+extern const uint32_t __ld_load_data;
+
+int safety_controller_trigger_flash_crc_check()
+{
+	/* This structs needs to be volatile!!
+	 * This prevents the compiler form optimizing out the reads to the crcs which will be patched in later by
+	 * a separate python script!
+	 */
+	static volatile const struct flash_crcs IN_SECTION(.flashcrc) crcs_in_flash =
+	{
+		.start_magic = 0xA8BE53F9UL,
+		.crc_section_ccm_data = 0UL,
+		.crc_section_text = 0UL,
+		.crc_section_data = 0UL,
+		.crc_section_vectors = 0UL,
+		.end_magic = 0xFFA582FFUL,
+	};
+
+	int ret = -1;
+	uint32_t len;
+	uint32_t crc;
+
+	/* Perform CRC check over vector table */
+	len = (uint32_t)((void *)&__ld_vectors_end - (void *)&__ld_vectors_start);
+	if (len % 4) {
+		safety_controller_report_error(ERR_FLAG_FLASH_CRC_CODE);
+	} else {
+		len /= 4;
+		crc_unit_reset();
+		crc_unit_input_array(&__ld_vectors_start, len);
+		crc = crc_unit_get_crc();
+		if (crc != crcs_in_flash.crc_section_vectors) {
+			safety_controller_report_error(ERR_FLAG_FLASH_CRC_CODE);
+		}
+	}
+
+	/* Perform CRC check over text section */
+	len = (uint32_t)((void *)&__ld_text_end - (void *)&__ld_text_start);
+	if (len % 4) {
+		safety_controller_report_error(ERR_FLAG_FLASH_CRC_CODE);
+	} else {
+		len /= 4;
+		crc_unit_reset();
+		crc_unit_input_array(&__ld_text_start, len);
+		crc = crc_unit_get_crc();
+		if (crc != crcs_in_flash.crc_section_text) {
+			safety_controller_report_error(ERR_FLAG_FLASH_CRC_CODE);
+		}
+	}
+
+	/* Perform CRC check over data section */
+	len = (uint32_t)((void *)&__ld_edata - (void *)&__ld_sdata);
+	if (len % 4) {
+		safety_controller_report_error(ERR_FLAG_FLASH_CRC_DATA);
+	} else {
+		len /= 4;
+		crc_unit_reset();
+		crc_unit_input_array(&__ld_load_data, len);
+		crc = crc_unit_get_crc();
+		if (crc != crcs_in_flash.crc_section_data) {
+			safety_controller_report_error(ERR_FLAG_FLASH_CRC_DATA);
+		}
+	}
+
+	/* Perform CRC check over ccm data section */
+	len = (uint32_t)((void *)&__ld_edata_ccm - (void *)&__ld_sdata_ccm);
+	if (len % 4) {
+		safety_controller_report_error(ERR_FLAG_FLASH_CRC_DATA);
+	} else {
+		len /= 4;
+		crc_unit_reset();
+		crc_unit_input_array(&__ld_load_ccm_data, len);
+		crc = crc_unit_get_crc();
+		if (crc != crcs_in_flash.crc_section_ccm_data) {
+			safety_controller_report_error(ERR_FLAG_FLASH_CRC_DATA);
+		}
+	}
+
+	ret = 0;
+	return ret;
+}
+
 int safety_controller_set_crc_monitor(enum crc_monitor mon, uint32_t password)
 {
 	uint32_t i;

stm-firmware/safety/safety-memory.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <reflow-controller/safety/safety-memory.h>
 #include <helper-macros/helper-macros.h>
@@ -99,8 +99,7 @@ static enum safety_memory_state safety_memory_get_header(struct safety_memory_he
 	res = 0;
 	if (header->boot_status_offset < wordsize_of(struct safety_memory_header))
 		res++;
-	if (header->config_overrides_offset < header->boot_status_offset +
-			wordsize_of(struct safety_memory_boot_status))
+	if (header->config_overrides_offset < header->boot_status_offset + wordsize_of(struct safety_memory_boot_status))
 		res++;
 	if (header->config_overrides_len > SAFETY_MEMORY_CONFIG_OVERRIDE_COUNT)
 		res++;
@@ -108,8 +107,7 @@ static enum safety_memory_state safety_memory_get_header(struct safety_memory_he
 		res++;
 	if (header->err_memory_offset < header->firmware_update_filename + (SAFETY_MEMORY_UPDATE_FILENAME_MAXSIZE / 4))
 		res++;
-	if (header->err_memory_end >= backup_ram_get_size_in_words() ||
-			header->err_memory_end < header->err_memory_offset)
+	if (header->err_memory_end >= backup_ram_get_size_in_words() || header->err_memory_end < header->err_memory_offset)
 		res++;
 
 	if (res) {
@@ -150,7 +148,7 @@ static void safety_memory_write_new_header(void)
 	safety_memory_write_and_patch_header(&header);
 }
 
-static int safety_memory_check_crc(void)
+static int safety_memory_check_crc()
 {
 	struct safety_memory_header header;
 	enum safety_memory_state state = safety_memory_get_header(&header);
@@ -183,7 +181,7 @@ static int safety_memory_check_crc(void)
 		return 0;
 }
 
-static int safety_memory_gen_crc(void)
+static int safety_memory_gen_crc()
 {
 	struct safety_memory_header header;
 	uint32_t word_addr;
@@ -270,8 +268,9 @@ int safety_memory_get_boot_status(struct safety_memory_boot_status *status)
 	if (!status)
 		return -1001;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	if (safety_memory_check_crc())
 		return -2001;
@@ -290,8 +289,9 @@ int safety_memory_set_boot_status(const struct safety_memory_boot_status *status
 	if (!status)
 		return -1001;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	if (safety_memory_check_crc())
 		return -2001;
@@ -304,7 +304,7 @@ int safety_memory_set_boot_status(const struct safety_memory_boot_status *status
 	return 0;
 }
 
-static int safety_memory_check_error_entries(void)
+static int safety_memory_check_error_entries()
 {
 	struct safety_memory_header header;
 	uint32_t addr;
@@ -312,8 +312,9 @@ static int safety_memory_check_error_entries(void)
 	int ret = 0;
 	int res;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	for (addr = header.err_memory_offset; addr < header.err_memory_end; addr++) {
 		res = backup_ram_get_data(addr, &data, 1UL);
@@ -339,8 +340,9 @@ int safety_memory_get_error_entry_count(uint32_t *count)
 	if (!count)
 		return -1001;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	*count = header.err_memory_end - header.err_memory_offset;
 
@@ -352,8 +354,9 @@ int safety_memory_check(void)
 	int res;
 
 	res = safety_memory_check_crc();
-	if (!res)
+	if (!res) {
 		res |= safety_memory_check_error_entries();
+	}
 
 	return -!!res;
 }
@@ -369,8 +372,9 @@ int safety_memory_get_error_entry(uint32_t idx, struct error_memory_entry *entry
 	if (!entry)
 		return -1001;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	err_mem_count = header.err_memory_end - header.err_memory_offset;
 	if (idx < err_mem_count && err_mem_count > 0) {
@@ -406,8 +410,9 @@ int safety_memory_insert_error_entry(struct error_memory_entry *entry)
 
 	input_data = error_memory_entry_to_word(entry);
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	if (entry->type == SAFETY_MEMORY_ERR_ENTRY_NOP) {
 		/* Append to end */
@@ -505,8 +510,9 @@ int safety_memory_insert_config_override(struct config_override *config_override
 	int res;
 	int ret = -3;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	if (header.config_overrides_len == 0)
 		return -1;
@@ -544,8 +550,9 @@ int safety_memory_get_config_override_count(uint32_t *count)
 
 	*count = 0UL;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
 	if (header.config_overrides_len == 0)
 		return 0;
@@ -575,15 +582,18 @@ int safety_memory_get_config_override(uint32_t idx, struct config_override *conf
 	if (!config_override)
 		return -1002;
 
-	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY)
+	if (safety_memory_get_header(&header) != SAFETY_MEMORY_INIT_VALID_MEMORY) {
 		return -2000;
+	}
 
-	if (idx >= header.config_overrides_len)
+	if (idx >= header.config_overrides_len) {
 		return -1001;
+	}
 
 	res = backup_ram_get_data(header.config_overrides_offset + idx, &data, 1UL);
-	if (res)
+	if (res) {
 		return -1;
+	}
 
 	switch (data & 0xFF) {
 	case 0xA2:
@@ -639,8 +649,8 @@ int safety_memory_get_update_filename(char *filename, size_t *outlen)
 {
 	struct safety_memory_header header;
 	unsigned int i;
-	size_t len = 0u;
 	volatile char *ptr;
+	size_t len = 0u;
 
 	/* If filename and outlen are both NULL, we don't do anything */
 	if (!filename && !outlen)
@@ -686,9 +696,9 @@ int safety_memory_set_update_filename(const char *filename)
 	ram_ptr = backup_ram_get_base_ptr();
 	ram_ptr += header.firmware_update_filename * 4;
 
-	for (i = 0u; i < len; i++)
+	for (i = 0u; i < len; i++) {
 		ram_ptr[i] = filename[i];
-
+	}
 	ram_ptr[i] = 0;
 
 	ret = safety_memory_gen_crc();

stm-firmware/safety/stack-check.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <reflow-controller/safety/stack-check.h>
 #include <stdint.h>
@@ -26,7 +26,7 @@
 extern char __ld_top_of_stack;
 extern char __ld_end_stack;
 
-int32_t stack_check_get_usage(void)
+int32_t stack_check_get_usage()
 {
 	uint32_t stack_top;
 	uint32_t stack_ptr;
@@ -37,7 +37,7 @@ int32_t stack_check_get_usage(void)
 	return stack_top - stack_ptr;
 }
 
-int32_t stack_check_get_free(void)
+int32_t stack_check_get_free()
 {
 	uint32_t upper_heap_boundary;
 	uint32_t stack_ptr;
@@ -102,6 +102,9 @@ int stack_check_corruption_detect_area(void)
 						&__ld_start_stack_corruption_detect_area;
 	crc_unit_reset();
 	crc_unit_input_array(&__ld_start_stack_corruption_detect_area, area_size_in_words);
-
-	return crc_unit_get_crc() == 0UL ? 0 : -1;
+	if (crc_unit_get_crc() == 0UL) {
+		return 0;
+	} else {
+		return -1;
+	}
 }

stm-firmware/safety/watchdog.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 /**
  * @addtogroup watchdog
@@ -42,63 +42,52 @@
  */
 #define STM32_WATCHDOG_REGISTER_ACCESS_KEY 0x5555
 
-int watchdog_setup(uint16_t prescaler, uint16_t reload_value)
+int watchdog_setup(uint8_t prescaler)
 {
 	uint32_t prescaler_reg_val;
-	int ret = 0;
 
 	/** - Activate the LSI oscillator */
 	RCC->CSR |= RCC_CSR_LSION;
 	__DSB();
 	/** - Wait for the oscillator to be ready */
-	while (!(RCC->CSR & RCC_CSR_LSIRDY))
-		;
+	while (!(RCC->CSR & RCC_CSR_LSIRDY));
 
-	if (prescaler == 4U) {
+	if (prescaler == 4U)
 		prescaler_reg_val = 0UL;
-	} else if (prescaler == 8U) {
+	else if (prescaler == 8U)
 		prescaler_reg_val = 1UL;
-	} else if (prescaler == 16U) {
+	else if (prescaler == 16U)
 		prescaler_reg_val = 2UL;
-	} else if (prescaler == 32U) {
+	else if (prescaler == 32U)
 		prescaler_reg_val = 3UL;
-	} else if (prescaler == 64U) {
+	else if (prescaler == 64U)
 		prescaler_reg_val = 4UL;
-	} else if (prescaler == 128U) {
+	else if (prescaler == 128U)
 		prescaler_reg_val = 5UL;
-	} else if (prescaler == 256U) {
+	else
 		prescaler_reg_val = 6UL;
-	} else {
-		prescaler_reg_val = 6UL;
-		ret = -1;
-	}
 
 	/** - (De)activate the watchdog during debug access according to @ref WATCHDOG_HALT_DEBUG */
-	if (WATCHDOG_HALT_DEBUG)
+	if (WATCHDOG_HALT_DEBUG) {
 		DBGMCU->APB1FZ |= DBGMCU_APB1_FZ_DBG_IWDG_STOP;
-	else
+	} else {
 		DBGMCU->APB1FZ &= ~DBGMCU_APB1_FZ_DBG_IWDG_STOP;
+	}
 
 	/** - Unlock registers */
 	IWDG->KR = STM32_WATCHDOG_REGISTER_ACCESS_KEY;
 
 	/** - Wait until prescaler can be written */
-	while (IWDG->SR & IWDG_SR_PVU)
-		;
+	while (IWDG->SR & IWDG_SR_PVU);
 
 	/** - Write prescaler value */
 	IWDG->PR = prescaler_reg_val;
 
 	/* - Wait until reload value can be written */
-	while (IWDG->SR & IWDG_SR_RVU)
-		;
+	while (IWDG->SR & IWDG_SR_RVU);
 
-	/** - Set reload value */
-	if (reload_value > 0xFFFu) {
-		reload_value = 0xFFFFu;
-		ret = -2;
-	}
-	IWDG->RLR = reload_value;
+	/** - Set reload value fixed to 0xFFF */
+	IWDG->RLR = 0xFFFU;
 
 	/** - Write enable key */
 	IWDG->KR = STM32_WATCHDOG_ENABLE_KEY;
@@ -106,7 +95,7 @@ int watchdog_setup(uint16_t prescaler, uint16_t reload_value)
 	/** - Do a first reset of the counter. This also locks the config regs */
 	watchdog_ack(WATCHDOG_MAGIC_KEY);
 
-	return ret;
+	return 0;
 }
 
 int watchdog_ack(uint32_t magic)

stm-firmware/sd.c

@@ -1,65 +0,0 @@
-/* Reflow Oven Controller
- *
- * Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * GDSII-Converter is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <reflow-controller/sd.h>
-#include "fatfs/ff.h"
-#include "fatfs/shimatta_sdio_driver/shimatta_sdio.h"
-#include <stdint.h>
-#include <string.h>
-#include <helper-macros/helper-macros.h>
-#include <reflow-controller/digio.h>
-
-static bool sd_card_mounted_state = false;
-
-bool mount_sd_card_if_avail(FATFS *fs)
-{
-	FRESULT res;
-	static uint8_t IN_SECTION(.ccm.bss) inserted_counter = 0;
-
-	if (sdio_check_inserted() && sd_card_mounted_state) {
-		memset(fs, 0, sizeof(FATFS));
-		sdio_stop_clk();
-		inserted_counter = 0;
-		sd_card_mounted_state = false;
-		goto ret;
-	}
-
-	if (!sdio_check_inserted() && inserted_counter < 255)
-		inserted_counter++;
-
-	if (!sdio_check_inserted() && !sd_card_mounted_state && inserted_counter > 4) {
-		inserted_counter = 0;
-		res = f_mount(fs, "0:/", 1);
-		if (res == FR_OK) {
-			led_set(1, 1);
-			sd_card_mounted_state = true;
-		} else {
-			sd_card_mounted_state = false;
-		}
-	}
-
-ret:
-	return sd_card_mounted_state;
-}
-
-bool sd_card_is_mounted(void)
-{
-	return sd_card_mounted_state;
-}

stm-firmware/settings/settings-eeprom.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <reflow-controller/settings/settings-eeprom.h>
 #include <reflow-controller/settings/spi-eeprom.h>
@@ -37,7 +37,6 @@ struct eeprom_calibration_settings {
 };
 
 #define EEPROM_OVER_TEMP_CONFIG_BASE_ADDR (EEPROM_CALIBRATION_BASE_ADDR + sizeof(struct eeprom_calibration_settings))
-
 struct eeprom_over_temp_config {
 	float over_temperature;
 	uint32_t over_temp_crc;
@@ -55,7 +54,7 @@ static bool check_eeprom_header(void)
 		return true;
 }
 
-static void settings_eeprom_zero(void)
+static void settings_eeprom_zero()
 {
 	settings_eeprom_save_calibration(0.0f, 0.0f, false);
 	settings_eeprom_save_overtemp_limit(0.0f, false);
@@ -63,7 +62,7 @@ static void settings_eeprom_zero(void)
 
 bool settings_eeprom_detect_and_prepare(void)
 {
-	bool eeprom_ready = false;
+	bool eeprom_ready = false;;
 
 	int res;
 
@@ -78,10 +77,7 @@ bool settings_eeprom_detect_and_prepare(void)
 	if (check_eeprom_header() == false) {
 		/* Try to write a new header and check it again */
 		spi_eeprom_write(0, expected_header, sizeof(expected_header));
-
-		while (spi_eeprom_write_in_progress())
-			;
-
+		while (spi_eeprom_write_in_progress());
 		if (check_eeprom_header() == false) {
 			goto ret_deinit_crc;
 		} else {

stm-firmware/settings/settings-sd-card.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <reflow-controller/settings/settings-sd-card.h>
 #include <stm-periph/unique-id.h>
@@ -72,12 +72,18 @@ static int create_controller_folder(void)
 		ret = 0;
 	} else {
 		filesystem_result = f_mkdir(foldername);
-		ret = filesystem_result == FR_OK ? 1 : -1;
+		if (filesystem_result == FR_OK) {
+			ret = 1;
+		} else {
+			ret = -1;
+		}
 	}
 
 	return ret;
 }
 
+
+
 int sd_card_settings_save_calibration(float sens_deviation, float offset, bool active)
 {
 	char path[200];

stm-firmware/settings/settings.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <reflow-controller/settings/settings.h>
 #include <reflow-controller/settings/settings-sd-card.h>
@@ -39,7 +39,7 @@ int settings_load_calibration(float *sens_dev, float *offset)
 	int res;
 
 	if (settings_use_eeprom) {
-		res = settings_eeprom_load_calibration(sens_dev, offset, &active);
+		res =settings_eeprom_load_calibration(sens_dev, offset, &active);
 		if (!res && !active)
 			res = -1;
 	} else  {

stm-firmware/settings/spi-eeprom.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2021  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2021  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <reflow-controller/settings/spi-eeprom.h>
 #include <stm-periph/spi.h>
@@ -52,7 +52,7 @@ static void eeprom_cs_deactivate(void)
 	SPI_EEPROM_SPI_PORT->ODR |= (1<<SPI_EEPROM_CS_PIN);
 }
 
-int spi_eeprom_init(void)
+int spi_eeprom_init()
 {
 	static struct stm_spi_dev spi_dev;
 	struct stm_spi_settings settings;
@@ -61,8 +61,7 @@ int spi_eeprom_init(void)
 
 	SPI_EEPROM_SPI_PORT->MODER &= MODER_DELETE(SPI_EEPROM_CS_PIN) & MODER_DELETE(SPI_EEPROM_MISO_PIN) &
 			MODER_DELETE(SPI_EEPROM_MOSI_PIN) & MODER_DELETE(SPI_EEPROM_SCK_PIN);
-	SPI_EEPROM_SPI_PORT->MODER |= ALTFUNC(SPI_EEPROM_MISO_PIN) | ALTFUNC(SPI_EEPROM_SCK_PIN) |
-			ALTFUNC(SPI_EEPROM_MOSI_PIN);
+	SPI_EEPROM_SPI_PORT->MODER |= ALTFUNC(SPI_EEPROM_MISO_PIN) | ALTFUNC(SPI_EEPROM_SCK_PIN) | ALTFUNC(SPI_EEPROM_MOSI_PIN);
 	SPI_EEPROM_SPI_PORT->MODER |= OUTPUT(SPI_EEPROM_CS_PIN);
 
 	SETAF(SPI_EEPROM_SPI_PORT, SPI_EEPROM_MISO_PIN, SPI_EEPROM_SPI_ALTFUNC_NO);
@@ -86,7 +85,7 @@ int spi_eeprom_init(void)
 		return -1;
 }
 
-void spi_eeprom_deinit(void)
+void spi_eeprom_deinit()
 {
 	spi_deinit(eeprom_spi_handle);
 
@@ -167,8 +166,7 @@ static void spi_eeprom_do_write_page(uint32_t addr, const uint8_t *data, uint8_t
 	uint8_t cmd[2];
 
 	/* Wait for the previous write to finish */
-	while (spi_eeprom_write_in_progress())
-		;
+	while (spi_eeprom_write_in_progress());
 	/* Set the write enable latch */
 	spi_eeprom_set_write_enable_latch(true);
 

stm-firmware/stm-periph/backup-ram.c

@@ -46,8 +46,7 @@ void backup_ram_init(bool use_backup_regulator)
 		PWR->CSR |= PWR_CSR_BRE;
 
 		/* Wait until regulator is ready */
-		while (!(PWR->CSR & PWR_CSR_BRR))
-			;
+		while (!(PWR->CSR & PWR_CSR_BRR));
 	}
 
 	/* Enable clock for backup ram interface */

stm-firmware/stm-periph/dma-ring-buffer.c

@@ -37,10 +37,11 @@ static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_id
 {
 	size_t fill_level;
 
-	if (put_idx >= get_idx)
+	if (put_idx >= get_idx) {
 		fill_level = (put_idx - get_idx);
-	else
+	} else {
 		fill_level = buffer_size - get_idx + put_idx;
+	}
 
 	return fill_level;
 }
@@ -48,7 +49,7 @@ static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_id
 static int dma_ring_buffer_switch_clock_enable(uint8_t base_dma, bool clk_en)
 {
 	int ret_val;
-	int (*clk_func)(volatile uint32_t *reg, uint8_t bit_no);
+	int (*clk_func)(volatile uint32_t *, uint8_t);
 
 	if (clk_en)
 		clk_func = rcc_manager_enable_clock;
@@ -71,9 +72,8 @@ static int dma_ring_buffer_switch_clock_enable(uint8_t base_dma, bool clk_en)
 }
 
 int dma_ring_buffer_periph_to_mem_initialize(struct dma_ring_buffer_to_mem *dma_buffer, uint8_t base_dma_id,
-					     DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count,
-					     size_t element_size, volatile void *data_buffer,
-					     void *src_reg, uint8_t dma_trigger_channel)
+					     DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count, size_t element_size,
+					     volatile void *data_buffer, void* src_reg, uint8_t dma_trigger_channel)
 {
 	int ret_val = 0;
 
@@ -106,8 +106,7 @@ int dma_ring_buffer_periph_to_mem_initialize(struct dma_ring_buffer_to_mem *dma_
 	return 0;
 }
 
-int dma_ring_buffer_periph_to_mem_get_data(struct dma_ring_buffer_to_mem *buff, const volatile void **data_buff,
-						size_t *len)
+int dma_ring_buffer_periph_to_mem_get_data(struct dma_ring_buffer_to_mem *buff, const volatile void **data_buff, size_t *len)
 {
 	int ret_code = 0;
 	uint32_t ndtr;
@@ -168,10 +167,7 @@ int dma_ring_buffer_periph_to_mem_fill_level(struct dma_ring_buffer_to_mem *buff
 	return 0;
 }
 
-int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *dma_buffer, uint8_t base_dma_id,
-					     DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count,
-					     size_t element_size, volatile void *data_buffer,
-					     uint8_t dma_trigger_channel, void *dest_reg)
+int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *dma_buffer, uint8_t base_dma_id, DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count, size_t element_size, volatile void *data_buffer, uint8_t dma_trigger_channel, void *dest_reg)
 {
 	if (!dma_buffer || !dma_stream || !data_buffer || !dest_reg)
 		return -1000;
@@ -225,8 +221,7 @@ static void queue_or_start_dma_transfer(struct dma_ring_buffer_to_periph *buff)
 	buff->dma->CR |= DMA_SxCR_EN;
 }
 
-int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *buff, const void *data_to_insert,
-					      size_t count)
+int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *buff, const void *data_to_insert, size_t count)
 {
 	int ret = 0;
 	size_t free_item_count;
@@ -239,8 +234,7 @@ int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *
 		return -1000;
 
 	/* Check if data fits into buffer minus one element. If not: try full-1 buffer and rest
-	 * Buffer is not allowed to be completely full, because I cannot ddifferentiate a full buffer from a
-	 * completely empty one
+	 * Buffer is not allowed to be completely full, because I cannot ddifferentiate a full buffer from a completely empty one
 	 */
 	if (count >= buff->buffer_count) {
 		ret = dma_ring_buffer_mem_to_periph_insert_data(buff, data_to_insert, buff->buffer_count - 1);
@@ -253,9 +247,7 @@ int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *
 
 	/* Wait for buffer to be able to handle input */
 	do {
-		free_item_count = buff->buffer_count -
-				calculate_ring_buffer_fill_level(buff->buffer_count, buff->dma_get_idx_current,
-								 buff->sw_put_idx);
+		free_item_count = buff->buffer_count - calculate_ring_buffer_fill_level(buff->buffer_count, buff->dma_get_idx_current, buff->sw_put_idx);
 	} while (free_item_count < count+1);
 
 	/* Fillup buffer (max is buffer end, wrap around afterwards) */
@@ -269,7 +261,7 @@ int dma_ring_buffer_mem_to_periph_insert_data(struct dma_ring_buffer_to_periph *
 		buff->sw_put_idx += count;
 
 		/* If buffer is used up to last element, set put index to beginning */
-		if (buff->sw_put_idx >= buff->buffer_count)
+		if(buff->sw_put_idx >= buff->buffer_count)
 			buff->sw_put_idx = 0;
 	} else {
 		/* Fill up to end of buffer and fill rest after wrap around */

stm-firmware/stm-periph/option-bytes.c

@@ -76,14 +76,12 @@ int stm_option_bytes_program(const struct option_bytes *opts)
 	reg |= (opts->read_protection << 8) & FLASH_OPTCR_RDP;
 	reg |= (opts->wdg_sw << 5) & FLASH_OPTCR_WDG_SW;
 
-	while (FLASH->SR & FLASH_SR_BSY)
-		;
+	while (FLASH->SR & FLASH_SR_BSY);
 
 	FLASH->OPTCR = reg;
 	FLASH->OPTCR |= FLASH_OPTCR_OPTSTRT;
 	__DSB();
-	while (FLASH->SR & FLASH_SR_BSY)
-		;
+	while (FLASH->SR & FLASH_SR_BSY);
 
 	FLASH->OPTCR |= FLASH_OPTCR_OPTLOCK;
 

stm-firmware/stm-periph/rcc-manager.c

@@ -95,8 +95,9 @@ int rcc_manager_enable_clock(volatile uint32_t *rcc_enable_register, uint8_t bit
 	int ret_val = 0;
 	struct rcc_enable_count *entry;
 
-	if (!rcc_enable_register || bit_no > 31)
+	if (!rcc_enable_register || bit_no > 31) {
 		return -1000;
+	}
 
 	/* Enable the clock in any case, no matter what follows */
 	*rcc_enable_register |= (1U<<bit_no);
@@ -131,8 +132,9 @@ int rcc_manager_disable_clock(volatile uint32_t *rcc_enable_register, uint8_t bi
 	int ret_val = -1;
 	struct rcc_enable_count *entry;
 
-	if (!rcc_enable_register || bit_no > 31)
+	if (!rcc_enable_register || bit_no > 31) {
 		return -1000;
+	}
 
 	entry = search_enable_entry_in_list(rcc_enable_register, bit_no);
 

stm-firmware/stm-periph/rng.c

@@ -30,7 +30,7 @@ void random_number_gen_init(bool int_enable)
 	random_number_gen_reset(int_enable);
 }
 
-void random_number_gen_deinit(void)
+void random_number_gen_deinit()
 {
 	RNG->CR = 0;
 	__DSB();
@@ -66,5 +66,5 @@ enum random_number_error random_number_gen_get_number(uint32_t *random_number, b
 		*random_number = RNG->DR;
 
 	/* Return from function with proper status */
-	return value_ready ? RNG_ERROR_OK : RNG_ERROR_NOT_READY;
+	return (value_ready ? RNG_ERROR_OK : RNG_ERROR_NOT_READY);
 }

stm-firmware/stm-periph/spi.c

@@ -1,22 +1,22 @@
 /* Reflow Oven Controller
- *
- * Copyright (C) 2021  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
+*
+* Copyright (C) 2021  Mario Hüttel <mario.huettel@gmx.net>
+*
+* This file is part of the Reflow Oven Controller Project.
+*
+* The reflow oven controller is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with the reflow oven controller project.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
 
 #include <stm-periph/spi.h>
 #include <helper-macros/helper-macros.h>
@@ -65,8 +65,7 @@ static struct stm_spi_dev *spi_handle_to_struct(stm_spi_handle handle)
 	return dev;
 }
 
-stm_spi_handle spi_init(struct stm_spi_dev *spi_dev_struct, SPI_TypeDef *spi_regs,
-			const struct stm_spi_settings *settings)
+stm_spi_handle spi_init(struct stm_spi_dev *spi_dev_struct, SPI_TypeDef *spi_regs, const struct stm_spi_settings *settings)
 {
 	stm_spi_handle ret_handle = NULL;
 	uint32_t reg_val;
@@ -132,14 +131,10 @@ void spi_deinit(stm_spi_handle handle)
 
 static uint8_t transfer_byte(uint8_t byte, struct stm_spi_dev *dev)
 {
-	while (dev->spi_regs->SR & SPI_SR_BSY)
-		;
-
+	while (dev->spi_regs->SR & SPI_SR_BSY);
 	dev->spi_regs->DR = (uint16_t)byte;
 	__DSB();
-
-	while ((dev->spi_regs->SR & SPI_SR_BSY) || !(dev->spi_regs->SR & SPI_SR_TXE))
-		;
+	while((dev->spi_regs->SR & SPI_SR_BSY) || !(dev->spi_regs->SR & SPI_SR_TXE));
 
 	return (uint8_t)dev->spi_regs->DR;
 }

stm-firmware/stm-periph/uart.c

@@ -126,9 +126,7 @@ void uart_send_char(struct stm_uart *uart, char c)
 	if (!uart || !uart->uart_dev)
 		return;
 
-	while (!(uart->uart_dev->SR & USART_SR_TXE))
-		;
-
+	while(!(uart->uart_dev->SR & USART_SR_TXE));
 	uart->uart_dev->DR = c;
 }
 
@@ -177,8 +175,7 @@ char uart_get_char(struct stm_uart *uart)
 	if (!uart)
 		return 0;
 	/* Wait for data to be available */
-	while (!(uart->uart_dev->SR & USART_SR_RXNE))
-		;
+	while (!(uart->uart_dev->SR & USART_SR_RXNE));
 
 	return (char)uart->uart_dev->DR;
 }

stm-firmware/stm-periph/unique-id.c

@@ -43,23 +43,3 @@ void stm_dev_rev_id_get(uint32_t *device_id, uint32_t *revision_id)
 	if (revision_id)
 		*revision_id = (DBGMCU->IDCODE & DBGMCU_IDCODE_REV_ID) >> 16;
 }
-
-void stm_cpuid_get(uint8_t *implementer, uint8_t *variant, uint16_t *part_no, uint8_t *rev)
-{
-	uint32_t cpuid;
-
-	cpuid = SCB->CPUID;
-
-	if (implementer)
-		*implementer = (uint8_t)((cpuid >> 24) & 0xFFU);
-
-	if (variant)
-		*variant = (uint8_t)((cpuid >> 20) & 0x0FU);
-
-	if (part_no)
-		*part_no = (uint16_t)((cpuid >> 4) & 0x0FFFU);
-
-	if (rev)
-		*rev = (uint8_t)(cpuid & 0x0FU);
-
-}

stm-firmware/ui/gui.c

@@ -18,12 +18,10 @@
 * If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "reflow-controller/version.h"
 #include <reflow-controller/ui/gui.h>
 #include <reflow-controller/ui/gui-config.h>
 #include <reflow-controller/ui/menu.h>
 #include <reflow-controller/ui/lcd.h>
-#include <reflow-controller/sd.h>
 #include <reflow-controller/ui/rotary-encoder.h>
 #include <reflow-controller/systick.h>
 #include <reflow-controller/adc-meas.h>
@@ -168,9 +166,9 @@ static void gui_menu_about(struct lcd_menu *menu, enum menu_entry_func_entry ent
 			break;
 		last_page = 1;
 		menu_lcd_output(menu, 0, "Version Number:");
-		menu_lcd_outputf(menu, 1, "%.*s", LCD_CHAR_WIDTH, version_git_version_string);
-		if (strlen(version_git_version_string) > LCD_CHAR_WIDTH) {
-			menu_lcd_outputf(menu, 2, "%s", &version_git_version_string[LCD_CHAR_WIDTH]);
+		menu_lcd_outputf(menu, 1, "%.*s", LCD_CHAR_WIDTH, xstr(GIT_VER));
+		if (strlen(xstr(GIT_VER)) > LCD_CHAR_WIDTH) {
+			menu_lcd_outputf(menu, 2, "%s", &xstr(GIT_VER)[LCD_CHAR_WIDTH]);
 		}
 #ifdef DEBUGBUILD
 		menu_lcd_output(menu, 3, "Page 2/5 [DEBUG]");
@@ -693,37 +691,6 @@ static void gui_update_firmware(struct lcd_menu *menu, enum menu_entry_func_entr
 	}
 }
 
-static void gui_connector_info(struct lcd_menu *menu, enum menu_entry_func_entry entry_type, void *parent)
-{
-	static void *my_parent;
-	enum button_state button;
-
-	if (entry_type == MENU_ENTRY_FIRST_ENTER) {
-		my_parent = parent;
-		menu_display_clear(menu);
-
-		menu_lcd_output(menu, 0, "2,4: DIGIO[0,1]");
-		menu_lcd_output(menu, 1, "6: DIGIO2 (TX)");
-		menu_lcd_output(menu, 2, "8: DIGIO3 (RX)");
-		menu_lcd_output(menu, 3, "10:3V3 Rest:GND");
-	}
-
-	if (menu_get_button_ready_state(menu)) {
-		/* Buttons are ready. Read button */
-		button = menu_get_button_state(menu);
-		/* Throw away any rotation */
-		(void)menu_get_rotary_delta(menu);
-
-		if (button == BUTTON_SHORT_RELEASED || button == BUTTON_LONG ||
-				button == BUTTON_LONG_RELEASED) {
-			/* Exit menu */
-			menu_entry_dropback(menu, my_parent);
-		}
-	}
-
-
-}
-
 static char *overlay_heading = NULL;
 static char *overlay_text = NULL;
 
@@ -773,7 +740,6 @@ static void gui_menu_root_entry(struct lcd_menu *menu, enum menu_entry_func_entr
 		"Error Flags",
 		"About",
 		"Update",
-		"Connector Info",
 		NULL
 	};
 	static const menu_func_t root_entry_funcs[] = {
@@ -783,7 +749,6 @@ static void gui_menu_root_entry(struct lcd_menu *menu, enum menu_entry_func_entr
 		gui_menu_err_flags,
 		gui_menu_about,
 		gui_update_firmware,
-		gui_connector_info,
 	};
 	enum button_state push_button;
 	int16_t rot_delta;
@@ -791,6 +756,7 @@ static void gui_menu_root_entry(struct lcd_menu *menu, enum menu_entry_func_entr
 	if (entry_type != MENU_ENTRY_CONTINUE) {
 		menu_changed = true;
 		menu_display_clear(menu);
+		update_display_buffer(0, "Main Menu");
 		menu_ack_rotary_delta(menu);
 		if (entry_type == MENU_ENTRY_FIRST_ENTER) {
 			list.entry_names = root_entry_names;
@@ -801,8 +767,6 @@ static void gui_menu_root_entry(struct lcd_menu *menu, enum menu_entry_func_entr
 		}
 	}
 
-	update_display_buffer(0, sd_card_is_mounted() ? "Main Menu [SD]" : "Main Menu [--]");
-
 	push_button = menu_get_button_state(menu);
 	rot_delta = menu_get_rotary_delta(menu);
 

stm-firmware/ui/shell.c

@@ -48,11 +48,13 @@
 #include <stm-periph/option-bytes.h>
 #include <reflow-controller/ui/gui.h>
 #include <reflow-controller/ui/shell-uart.h>
-#include <reflow-controller/safety/flash-crc.h>
-#include <reflow-controller/version.h>
 
 #include <stdio.h>
 
+#ifndef GIT_VER
+#define GIT_VER "VERSION NOT SET"
+#endif
+
 static shellmatta_instance_t shell;
 static char shell_buffer[512];
 static char IN_SECTION(.ccm.bss) history_buffer[512];
@@ -68,19 +70,14 @@ static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
 	uint32_t high_id;
 	uint32_t stm_rev_id;
 	uint32_t stm_dev_id;
-	uint8_t core_rev;
-	uint8_t core_implementer;
-	uint8_t core_variant;
-	uint16_t core_part_no;
 	const char *hw_rev_str;
 	enum hw_revision pcb_rev;
 
 	stm_unique_id_get(&high_id, &mid_id, &low_id);
 	stm_dev_rev_id_get(&stm_dev_id, &stm_rev_id);
 
-	shellmatta_printf(handle, "Reflow Oven Controller Firmware %s\r\n"
-				"Compiled: %s at %s\r\n",
-				version_git_version_string, version_compile_date, version_compile_time);
+	shellmatta_printf(handle, "Reflow Oven Controller Firmware " xstr(GIT_VER) "\r\n"
+				"Compiled: " __DATE__ " at " __TIME__ "\r\n");
 	shellmatta_printf(handle, "Serial: %08X-%08X-%08X\r\n", high_id, mid_id, low_id);
 
 	pcb_rev = get_pcb_hardware_version();
@@ -103,12 +100,6 @@ static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
 	shellmatta_printf(handle, "STM Device ID: 0x%04X\r\n", stm_dev_id);
 	shellmatta_printf(handle, "STM Revision ID: 0x%04X\r\n", stm_rev_id);
 
-	stm_cpuid_get(&core_implementer, &core_variant, &core_part_no, &core_rev);
-	shellmatta_printf(handle, "CPU Implementer: 0x%02X\r\n", (unsigned int)core_implementer);
-	shellmatta_printf(handle, "CPU Variant: 0x%02X\r\n", (unsigned int)core_variant);
-	shellmatta_printf(handle, "CPU Part No.: 0x%04X\r\n", (unsigned int)core_part_no);
-	shellmatta_printf(handle, "CPU Revision: 0x%02X\r\n", (unsigned int)core_rev);
-
 	return SHELLMATTA_OK;
 }
 
@@ -858,7 +849,6 @@ shellmatta_retCode_t shell_cmd_execute(const shellmatta_handle_t handle, const c
 shellmatta_retCode_t shell_cmd_cycle_count(const shellmatta_handle_t handle, const char *args, uint32_t len)
 {
 	uint64_t counter;
-	uint32_t core_cycle_count;
 	(void)args;
 	(void)len;
 	char option;
@@ -866,10 +856,8 @@ shellmatta_retCode_t shell_cmd_cycle_count(const shellmatta_handle_t handle, con
 	uint32_t arg_len;
 	int opt_stat;
 	bool clear = false;
-	bool hex = false;
 	const shellmatta_opt_long_t options[] = {
 		{"clear", 'c', SHELLMATTA_OPT_ARG_NONE},
-		{"hex", 'h', SHELLMATTA_OPT_ARG_NONE},
 		{NULL, '\0', SHELLMATTA_OPT_ARG_NONE},
 	};
 
@@ -881,8 +869,6 @@ shellmatta_retCode_t shell_cmd_cycle_count(const shellmatta_handle_t handle, con
 		case 'c':
 			clear = true;
 			break;
-		case 'h':
-			hex = true;
 		default:
 			break;
 		}
@@ -890,18 +876,10 @@ shellmatta_retCode_t shell_cmd_cycle_count(const shellmatta_handle_t handle, con
 
 
 	counter = main_cycle_counter_get();
-	core_cycle_count = core_cycle_counter_get();
-	if (hex) {
-		shellmatta_printf(handle, "Main loop: 0x%016"PRIX64"\r\n", counter);
-		shellmatta_printf(handle, "CPU cycles: 0x%08"PRIX32"\r\n", core_cycle_count);
-	} else {
-		shellmatta_printf(handle, "Main loop: %"PRIu64"\r\n", counter);
-		shellmatta_printf(handle, "CPU cycles: %"PRIu32"\r\n", core_cycle_count);
-	}
-	if (clear) {
-		main_cycle_counter_reset();
-		core_cycle_counter_reset();
-	}
+	shellmatta_printf(handle, "%"PRIu64"\r\n", counter);
+	if (clear)
+		main_cycle_counter_init();
+
 	return SHELLMATTA_OK;
 }
 
@@ -1019,53 +997,6 @@ shellmatta_retCode_t shell_cmd_set_baud(const shellmatta_handle_t handle, const
 	return SHELLMATTA_OK;
 }
 
-static void shell_print_crc_line(const shellmatta_handle_t handle, const char *name,
-				 uint32_t crc, uint32_t crc_expected)
-{
-	shellmatta_printf(handle, "%-15s0x%08x    0x%08x  [%s]\r\n",
-			  name,
-			  crc,
-			  crc_expected,
-			  crc != crc_expected ? "\e[1;31mERR\e[m" : "\e[32mOK\e[m");
-}
-
-shellmatta_retCode_t shell_cmd_flash_crc(const shellmatta_handle_t handle, const char *args, uint32_t len)
-{
-	(void)args;
-	(void)len;
-	uint32_t crc = 0;
-	uint32_t crc_expected = 0;
-	int res;
-
-	shellmatta_printf(handle, "               Calculated    Expected    State\r\n\r\n");
-
-	res = flash_crc_calc_section(FLASH_CRC_VECTOR, &crc);
-	crc_expected = flash_crc_get_expected_crc(FLASH_CRC_VECTOR);
-	if (res)
-		shellmatta_printf(handle, "Error during calculation!\r\n");
-	shell_print_crc_line(handle, "Vector CRC:", crc, crc_expected);
-
-	res = flash_crc_calc_section(FLASH_CRC_TEXT, &crc);
-	crc_expected = flash_crc_get_expected_crc(FLASH_CRC_TEXT);
-	if (res)
-		shellmatta_printf(handle, "Error during calculation!\r\n");
-	shell_print_crc_line(handle, "Code CRC:", crc, crc_expected);
-
-	res = flash_crc_calc_section(FLASH_CRC_DATA, &crc);
-	crc_expected = flash_crc_get_expected_crc(FLASH_CRC_DATA);
-	if (res)
-		shellmatta_printf(handle, "Error during calculation!\r\n");
-	shell_print_crc_line(handle, "Data CRC:", crc, crc_expected);
-
-	res = flash_crc_calc_section(FLASH_CRC_CCMDATA, &crc);
-	crc_expected = flash_crc_get_expected_crc(FLASH_CRC_CCMDATA);
-	if (res)
-		shellmatta_printf(handle, "Error during calculation!\r\n");
-	shell_print_crc_line(handle, "CCM Data CRC:", crc, crc_expected);
-
-	return SHELLMATTA_OK;
-}
-
 //typedef struct shellmatta_cmd
 //{
 //    char                    *cmd;       /**< command name                           */
@@ -1075,7 +1006,7 @@ shellmatta_retCode_t shell_cmd_flash_crc(const shellmatta_handle_t handle, const
 //    shellmatta_cmdFct_t     cmdFct;     /**< pointer to the cmd callack function    */
 //    struct shellmatta_cmd   *next;      /**< pointer to next command or NULL        */
 //} shellmatta_cmd_t;
-static shellmatta_cmd_t cmd[26] = {
+static shellmatta_cmd_t cmd[25] = {
 	{
 		.cmd = "version",
 		.cmdAlias = "ver",
@@ -1271,18 +1202,10 @@ static shellmatta_cmd_t cmd[26] = {
 	},
 	{
 		.cmd = "baudrate",
-		.cmdAlias = "baud",
+		.cmdAlias = "opt-bytes",
 		.helpText = "Set a new temporary baudrate for the UART",
 		.usageText = "baudrate <new baud>",
 		.cmdFct = shell_cmd_set_baud,
-		.next = &cmd[25],
-	},
-	{
-		.cmd = "flashcrc",
-		.cmdAlias = "fcrc",
-		.helpText = "Calculate the Flash CRCs",
-		.usageText = "flashcrc",
-		.cmdFct = shell_cmd_flash_crc,
 		.next = NULL,
 	},
 

stm-firmware/updater/ram-code/CMakeLists.txt

@@ -31,7 +31,7 @@ add_executable(${ELFFILE} ${SRCS} ${FATFS_SRCS} ${SDIO_SRCS} ${STM_PERIPH_SRCS}
 target_include_directories(${ELFFILE} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include ../../include ${CMAKE_CURRENT_SOURCE_DIR}/3rd-party)
 target_compile_options(${ELFFILE} PRIVATE -Wall -Wextra -Wold-style-declaration -Wuninitialized -Wmaybe-uninitialized -Wunused-parameter)
 target_compile_options(${ELFFILE} PRIVATE -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles -Wimplicit-fallthrough=3 -Wsign-compare -Os -g3)
-target_compile_definitions(${ELFFILE} PRIVATE -DHSE_VALUE=8000000UL -DSTM32F407xx -DSTM32F4XX -DARM_MATH_CM4 -DSAFETY_MEMORY_STRIPOUT_DUMP)
+target_compile_definitions(${ELFFILE} PRIVATE -DGIT_VER=${GIT_DESCRIBE} -DHSE_VALUE=8000000UL -DSTM32F407xx -DSTM32F4XX -DARM_MATH_CM4 -DSAFETY_MEMORY_STRIPOUT_DUMP)
 target_link_options(${ELFFILE} PRIVATE -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork -mfloat-abi=hard -mfpu=fpv4-sp-d16 --disable-newlib-supplied-syscalls -nostartfiles -T${LINKER_SCRIPT} -Wl,--print-memory-usage)
 set(GEN_HEADER_PATH "${CMAKE_CURRENT_BINARY_DIR}/include/generated")
 set(GEN_HEADER_FILE "${GEN_HEADER_PATH}/${PROJECT_NAME}.bin.h")

stm-firmware/updater/ram-code/bin2carray.py

@@ -1,45 +1,35 @@
 #!env python
 
-"""
-Convert a file to a c array
-bin2carray <output file> <input file>
-"""
+# Convert a file to a c array
+# bin2carray <output file> <input file>
 
 import os
 import os.path
 import sys
 
-def main():
-    """
-    Main script function
-    """
-    if len(sys.argv) < 3:
-        return -1
+if len(sys.argv) < 3:
+	sys.exit(-1)
 
-    source_file = sys.argv[2]
-    dest_file = sys.argv[1]
+source_file = sys.argv[2]
+dest_file = sys.argv[1]
 
-    print(f'{source_file} --> {dest_file}')
+print("%s --> %s" % (source_file, dest_file))
 
-    with open(source_file, 'rb') as src:
+with open(source_file, "rb") as src:
 	data = src.read()
 
-    with open(dest_file, 'w', encoding='utf-8') as dest:
-        header_guard = '_' + os.path.basename(dest_file).replace('.', '_').replace('-', '_') + '_H_'
-        header_guard = header_guard.upper()
-        dest.write(f'#ifndef {header_guard}\n')
-        dest.write(f'#define {header_guard}\n')
-        dest.write(f'static const char binary_blob[{len(data)}] = {{\n')
-        for idx, current in enumerate(data, start=1):
-            if idx % 4 == 0:
-                dest.write(hex(current)+',\n')
+with open(dest_file, "w") as dest:
+	header_guard = "__" + os.path.basename(dest_file).replace('.', '_').replace('-', '_') + "_H__"
+	dest.write("#ifndef %s\n" % (header_guard))
+	dest.write("#define %s\n" % (header_guard))
+	dest.write("static const char binary_blob[%d] = {\n" % (len(data)))
+	for current,idx in zip(data, range(len(data))):
+		if ((idx+1) % 4 == 0):
+			dest.write(hex(current)+",\n")
 		else:
-                dest.write(hex(current)+',')
+			dest.write(hex(current)+",")
 
-        dest.write('};\n')
-        dest.write(f'#endif /* {header_guard} */\n')
+	dest.write("};\n")
+	dest.write("#endif /* %s */\n" % (header_guard))
 
-    return 0
-
-if __name__ == '__main__':
-    sys.exit(main())
+sys.exit(0)

stm-firmware/updater/ram-code/fatfs/ffsystem.c

@@ -1,208 +1,170 @@
 /*------------------------------------------------------------------------*/
-/* A Sample Code of User Provided OS Dependent Functions for FatFs        */
+/* Sample Code of OS Dependent Functions for FatFs                        */
+/* (C)ChaN, 2018                                                          */
 /*------------------------------------------------------------------------*/
 
+
 #include <fatfs/ff.h>
 
 
-#if FF_USE_LFN == 3	/* Use dynamic memory allocation */
+#if FF_USE_LFN == 3	/* Dynamic memory allocation */
 
 /*------------------------------------------------------------------------*/
-/* Allocate/Free a Memory Block                                           */
+/* Allocate a memory block                                                */
 /*------------------------------------------------------------------------*/
 
-#include <stdlib.h>		/* with POSIX API */
-
-
 void* ff_memalloc (	/* Returns pointer to the allocated memory block (null if not enough core) */
 	UINT msize		/* Number of bytes to allocate */
 )
 {
-	return malloc((size_t)msize);	/* Allocate a new memory block */
+	return malloc(msize);	/* Allocate a new memory block with POSIX API */
 }
 
 
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+
 void ff_memfree (
-	void* mblock	/* Pointer to the memory block to free (no effect if null) */
+	void* mblock	/* Pointer to the memory block to free (nothing to do if null) */
 )
 {
-	free(mblock);	/* Free the memory block */
+	free(mblock);	/* Free the memory block with POSIX API */
 }
 
 #endif
 
 
 
-
 #if FF_FS_REENTRANT	/* Mutal exclusion */
-/*------------------------------------------------------------------------*/
-/* Definitions of Mutex                                                   */
-/*------------------------------------------------------------------------*/
-
-#define OS_TYPE	0	/* 0:Win32, 1:uITRON4.0, 2:uC/OS-II, 3:FreeRTOS, 4:CMSIS-RTOS */
-
-
-#if   OS_TYPE == 0	/* Win32 */
-#include <windows.h>
-static HANDLE Mutex[FF_VOLUMES + 1];	/* Table of mutex handle */
-
-#elif OS_TYPE == 1	/* uITRON */
-#include "itron.h"
-#include "kernel.h"
-static mtxid Mutex[FF_VOLUMES + 1];		/* Table of mutex ID */
-
-#elif OS_TYPE == 2	/* uc/OS-II */
-#include "includes.h"
-static OS_EVENT *Mutex[FF_VOLUMES + 1];	/* Table of mutex pinter */
-
-#elif OS_TYPE == 3	/* FreeRTOS */
-#include "FreeRTOS.h"
-#include "semphr.h"
-static SemaphoreHandle_t Mutex[FF_VOLUMES + 1];	/* Table of mutex handle */
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-#include "cmsis_os.h"
-static osMutexId Mutex[FF_VOLUMES + 1];	/* Table of mutex ID */
-
-#endif
-
-
 
 /*------------------------------------------------------------------------*/
-/* Create a Mutex                                                         */
+/* Create a Synchronization Object                                        */
 /*------------------------------------------------------------------------*/
-/* This function is called in f_mount function to create a new mutex
-/  or semaphore for the volume. When a 0 is returned, the f_mount function
-/  fails with FR_INT_ERR.
+/* This function is called in f_mount() function to create a new
+/  synchronization object for the volume, such as semaphore and mutex.
+/  When a 0 is returned, the f_mount() function fails with FR_INT_ERR.
 */
 
-int ff_mutex_create (	/* Returns 1:Function succeeded or 0:Could not create the mutex */
-	int vol				/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+//const osMutexDef_t Mutex[FF_VOLUMES];	/* Table of CMSIS-RTOS mutex */
+
+
+int ff_cre_syncobj (	/* 1:Function succeeded, 0:Could not create the sync object */
+	BYTE vol,			/* Corresponding volume (logical drive number) */
+	FF_SYNC_t* sobj		/* Pointer to return the created sync object */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	Mutex[vol] = CreateMutex(NULL, FALSE, NULL);
-	return (int)(Mutex[vol] != INVALID_HANDLE_VALUE);
+	/* Win32 */
+	*sobj = CreateMutex(NULL, FALSE, NULL);
+	return (int)(*sobj != INVALID_HANDLE_VALUE);
 
-#elif OS_TYPE == 1	/* uITRON */
-	T_CMTX cmtx = {TA_TPRI,1};
+	/* uITRON */
+//	T_CSEM csem = {TA_TPRI,1,1};
+//	*sobj = acre_sem(&csem);
+//	return (int)(*sobj > 0);
 
-	Mutex[vol] = acre_mtx(&cmtx);
-	return (int)(Mutex[vol] > 0);
+	/* uC/OS-II */
+//	OS_ERR err;
+//	*sobj = OSMutexCreate(0, &err);
+//	return (int)(err == OS_NO_ERR);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OS_ERR err;
+	/* FreeRTOS */
+//	*sobj = xSemaphoreCreateMutex();
+//	return (int)(*sobj != NULL);
 
-	Mutex[vol] = OSMutexCreate(0, &err);
-	return (int)(err == OS_NO_ERR);
-
-#elif OS_TYPE == 3	/* FreeRTOS */
-	Mutex[vol] = xSemaphoreCreateMutex();
-	return (int)(Mutex[vol] != NULL);
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	osMutexDef(cmsis_os_mutex);
-
-	Mutex[vol] = osMutexCreate(osMutex(cmsis_os_mutex));
-	return (int)(Mutex[vol] != NULL);
-
-#endif
+	/* CMSIS-RTOS */
+//	*sobj = osMutexCreate(&Mutex[vol]);
+//	return (int)(*sobj != NULL);
 }
 
 
 /*------------------------------------------------------------------------*/
-/* Delete a Mutex                                                         */
+/* Delete a Synchronization Object                                        */
 /*------------------------------------------------------------------------*/
-/* This function is called in f_mount function to delete a mutex or
-/  semaphore of the volume created with ff_mutex_create function.
+/* This function is called in f_mount() function to delete a synchronization
+/  object that created with ff_cre_syncobj() function. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
 */
 
-void ff_mutex_delete (	/* Returns 1:Function succeeded or 0:Could not delete due to an error */
-	int vol				/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+int ff_del_syncobj (	/* 1:Function succeeded, 0:Could not delete due to an error */
+	FF_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	CloseHandle(Mutex[vol]);
+	/* Win32 */
+	return (int)CloseHandle(sobj);
 
-#elif OS_TYPE == 1	/* uITRON */
-	del_mtx(Mutex[vol]);
+	/* uITRON */
+//	return (int)(del_sem(sobj) == E_OK);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OS_ERR err;
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);
+//	return (int)(err == OS_NO_ERR);
 
-	OSMutexDel(Mutex[vol], OS_DEL_ALWAYS, &err);
+	/* FreeRTOS */
+//  vSemaphoreDelete(sobj);
+//	return 1;
 
-#elif OS_TYPE == 3	/* FreeRTOS */
-	vSemaphoreDelete(Mutex[vol]);
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	osMutexDelete(Mutex[vol]);
-
-#endif
+	/* CMSIS-RTOS */
+//	return (int)(osMutexDelete(sobj) == osOK);
 }
 
 
 /*------------------------------------------------------------------------*/
-/* Request a Grant to Access the Volume                                   */
+/* Request Grant to Access the Volume                                     */
 /*------------------------------------------------------------------------*/
-/* This function is called on enter file functions to lock the volume.
+/* This function is called on entering file functions to lock the volume.
 /  When a 0 is returned, the file function fails with FR_TIMEOUT.
 */
 
-int ff_mutex_take (	/* Returns 1:Succeeded or 0:Timeout */
-	int vol			/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
+	FF_SYNC_t sobj	/* Sync object to wait */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	return (int)(WaitForSingleObject(Mutex[vol], FF_FS_TIMEOUT) == WAIT_OBJECT_0);
+	/* Win32 */
+	return (int)(WaitForSingleObject(sobj, FF_FS_TIMEOUT) == WAIT_OBJECT_0);
 
-#elif OS_TYPE == 1	/* uITRON */
-	return (int)(tloc_mtx(Mutex[vol], FF_FS_TIMEOUT) == E_OK);
+	/* uITRON */
+//	return (int)(wai_sem(sobj) == E_OK);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OS_ERR err;
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexPend(sobj, FF_FS_TIMEOUT, &err));
+//	return (int)(err == OS_NO_ERR);
 
-	OSMutexPend(Mutex[vol], FF_FS_TIMEOUT, &err));
-	return (int)(err == OS_NO_ERR);
+	/* FreeRTOS */
+//	return (int)(xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);
 
-#elif OS_TYPE == 3	/* FreeRTOS */
-	return (int)(xSemaphoreTake(Mutex[vol], FF_FS_TIMEOUT) == pdTRUE);
-
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	return (int)(osMutexWait(Mutex[vol], FF_FS_TIMEOUT) == osOK);
-
-#endif
+	/* CMSIS-RTOS */
+//	return (int)(osMutexWait(sobj, FF_FS_TIMEOUT) == osOK);
 }
 
 
-
 /*------------------------------------------------------------------------*/
-/* Release a Grant to Access the Volume                                   */
+/* Release Grant to Access the Volume                                     */
 /*------------------------------------------------------------------------*/
-/* This function is called on leave file functions to unlock the volume.
+/* This function is called on leaving file functions to unlock the volume.
 */
 
-void ff_mutex_give (
-	int vol			/* Mutex ID: Volume mutex (0 to FF_VOLUMES - 1) or system mutex (FF_VOLUMES) */
+void ff_rel_grant (
+	FF_SYNC_t sobj	/* Sync object to be signaled */
 )
 {
-#if OS_TYPE == 0	/* Win32 */
-	ReleaseMutex(Mutex[vol]);
+	/* Win32 */
+	ReleaseMutex(sobj);
 
-#elif OS_TYPE == 1	/* uITRON */
-	unl_mtx(Mutex[vol]);
+	/* uITRON */
+//	sig_sem(sobj);
 
-#elif OS_TYPE == 2	/* uC/OS-II */
-	OSMutexPost(Mutex[vol]);
+	/* uC/OS-II */
+//	OSMutexPost(sobj);
 
-#elif OS_TYPE == 3	/* FreeRTOS */
-	xSemaphoreGive(Mutex[vol]);
+	/* FreeRTOS */
+//	xSemaphoreGive(sobj);
 
-#elif OS_TYPE == 4	/* CMSIS-RTOS */
-	osMutexRelease(Mutex[vol]);
-
-#endif
+	/* CMSIS-RTOS */
+//	osMutexRelease(sobj);
 }
 
-#endif	/* FF_FS_REENTRANT */
+#endif
 

stm-firmware/updater/ram-code/fatfs/ffunicode.c

@@ -1,13 +1,13 @@
 /*------------------------------------------------------------------------*/
-/* Unicode Handling Functions for FatFs R0.13 and Later                   */
-/*------------------------------------------------------------------------*/
-/* This module will occupy a huge memory in the .rodata section when the  */
-/* FatFs is configured for LFN with DBCS. If the system has a Unicode     */
-/* library for the code conversion, this module should be modified to use */
-/* it to avoid silly memory consumption.                                  */
+/* Unicode handling functions for FatFs R0.13+                            */
 /*------------------------------------------------------------------------*/
+/* This module will occupy a huge memory in the .const section when the    /
+/  FatFs is configured for LFN with DBCS. If the system has any Unicode    /
+/  utilitiy for the code conversion, this module should be modified to use /
+/  that function to avoid silly memory consumption.                        /
+/-------------------------------------------------------------------------*/
 /*
-/ Copyright (C) 2022, ChaN, all right reserved.
+/ Copyright (C) 2014, ChaN, all right reserved.
 /
 / FatFs module is an open source software. Redistribution and use of FatFs in
 / source and binary forms, with or without modification, are permitted provided
@@ -22,9 +22,10 @@
 / by use of this software.
 */
 
+
 #include <fatfs/ff.h>
 
-#if FF_USE_LFN != 0	/* This module will be blanked if in non-LFN configuration */
+#if FF_USE_LFN	/* This module will be blanked if non-LFN configuration */
 
 #define MERGE2(a, b) a ## b
 #define CVTBL(tbl, cp) MERGE2(tbl, cp)
@@ -15213,8 +15214,8 @@ static const WCHAR uc869[] = {	/*  CP869(Greek 2) to Unicode conversion table */
 
 
 /*------------------------------------------------------------------------*/
-/* OEM <==> Unicode Conversions for Static Code Page Configuration with   */
-/* SBCS Fixed Code Page                                                   */
+/* OEM <==> Unicode conversions for static code page configuration        */
+/* SBCS fixed code page                                                   */
 /*------------------------------------------------------------------------*/
 
 #if FF_CODE_PAGE != 0 && FF_CODE_PAGE < 900
@@ -15224,7 +15225,7 @@ WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
 )
 {
 	WCHAR c = 0;
-	const WCHAR* p = CVTBL(uc, FF_CODE_PAGE);
+	const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);
 
 
 	if (uni < 0x80) {	/* ASCII? */
@@ -15246,7 +15247,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 )
 {
 	WCHAR c = 0;
-	const WCHAR* p = CVTBL(uc, FF_CODE_PAGE);
+	const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);
 
 
 	if (oem < 0x80) {	/* ASCII? */
@@ -15266,8 +15267,8 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 
 
 /*------------------------------------------------------------------------*/
-/* OEM <==> Unicode Conversions for Static Code Page Configuration with   */
-/* DBCS Fixed Code Page                                                   */
+/* OEM <==> Unicode conversions for static code page configuration        */
+/* DBCS fixed code page                                                   */
 /*------------------------------------------------------------------------*/
 
 #if FF_CODE_PAGE >= 900
@@ -15276,7 +15277,7 @@ WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0, uc;
 	UINT i = 0, n, li, hi;
 
@@ -15312,7 +15313,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0;
 	UINT i = 0, n, li, hi;
 
@@ -15345,7 +15346,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 
 
 /*------------------------------------------------------------------------*/
-/* OEM <==> Unicode Conversions for Dynamic Code Page Configuration       */
+/* OEM <==> Unicode conversions for dynamic code page configuration       */
 /*------------------------------------------------------------------------*/
 
 #if FF_CODE_PAGE == 0
@@ -15359,7 +15360,7 @@ WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0, uc;
 	UINT i, n, li, hi;
 
@@ -15411,7 +15412,7 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 	WORD	cp		/* Code page for the conversion */
 )
 {
-	const WCHAR* p;
+	const WCHAR *p;
 	WCHAR c = 0;
 	UINT i, n, li, hi;
 
@@ -15457,14 +15458,14 @@ WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
 
 
 /*------------------------------------------------------------------------*/
-/* Unicode Up-case Conversion                                             */
+/* Unicode up-case conversion                                             */
 /*------------------------------------------------------------------------*/
 
 DWORD ff_wtoupper (	/* Returns up-converted code point */
 	DWORD uni		/* Unicode code point to be up-converted */
 )
 {
-	const WORD* p;
+	const WORD *p;
 	WORD uc, bc, nc, cmd;
 	static const WORD cvt1[] = {	/* Compressed up conversion table for U+0000 - U+0FFF */
 		/* Basic Latin */
@@ -15589,4 +15590,4 @@ DWORD ff_wtoupper (	/* Returns up-converted code point */
 }
 
 
-#endif /* #if FF_USE_LFN != 0 */
+#endif /* #if FF_USE_LFN */

stm-firmware/updater/ram-code/include/fatfs/ff.h

@@ -1,8 +1,8 @@
 /*----------------------------------------------------------------------------/
-/  FatFs - Generic FAT Filesystem module  R0.15                               /
+/  FatFs - Generic FAT Filesystem module  R0.14b                              /
 /-----------------------------------------------------------------------------/
 /
-/ Copyright (C) 2022, ChaN, all right reserved.
+/ Copyright (C) 2021, ChaN, all right reserved.
 /
 / FatFs module is an open source software. Redistribution and use of FatFs in
 / source and binary forms, with or without modification, are permitted provided
@@ -20,7 +20,7 @@
 
 
 #ifndef FF_DEFINED
-#define FF_DEFINED	80286	/* Revision ID */
+#define FF_DEFINED	86631	/* Revision ID */
 
 #ifdef __cplusplus
 extern "C" {
@@ -131,11 +131,10 @@ extern const char* VolumeStr[FF_VOLUMES];	/* User defied volume ID */
 
 typedef struct {
 	BYTE	fs_type;		/* Filesystem type (0:not mounted) */
-	BYTE	pdrv;			/* Volume hosting physical drive */
-	BYTE	ldrv;			/* Logical drive number (used only when FF_FS_REENTRANT) */
+	BYTE	pdrv;			/* Associated physical drive */
 	BYTE	n_fats;			/* Number of FATs (1 or 2) */
-	BYTE	wflag;			/* win[] status (b0:dirty) */
-	BYTE	fsi_flag;		/* FSINFO status (b7:disabled, b0:dirty) */
+	BYTE	wflag;			/* win[] flag (b0:dirty) */
+	BYTE	fsi_flag;		/* FSINFO flags (b7:disabled, b0:dirty) */
 	WORD	id;				/* Volume mount ID */
 	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
 	WORD	csize;			/* Cluster size [sectors] */
@@ -148,6 +147,9 @@ typedef struct {
 #if FF_FS_EXFAT
 	BYTE*	dirbuf;			/* Directory entry block scratchpad buffer for exFAT */
 #endif
+#if FF_FS_REENTRANT
+	FF_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
 #if !FF_FS_READONLY
 	DWORD	last_clst;		/* Last allocated cluster */
 	DWORD	free_clst;		/* Number of free clusters */
@@ -161,10 +163,10 @@ typedef struct {
 #endif
 #endif
 	DWORD	n_fatent;		/* Number of FAT entries (number of clusters + 2) */
-	DWORD	fsize;			/* Number of sectors per FAT */
+	DWORD	fsize;			/* Size of an FAT [sectors] */
 	LBA_t	volbase;		/* Volume base sector */
 	LBA_t	fatbase;		/* FAT base sector */
-	LBA_t	dirbase;		/* Root directory base sector (FAT12/16) or cluster (FAT32/exFAT) */
+	LBA_t	dirbase;		/* Root directory base sector/cluster */
 	LBA_t	database;		/* Data base sector */
 #if FF_FS_EXFAT
 	LBA_t	bitbase;		/* Allocation bitmap base sector */
@@ -179,7 +181,7 @@ typedef struct {
 
 typedef struct {
 	FATFS*	fs;				/* Pointer to the hosting volume of this object */
-	WORD	id;				/* Hosting volume's mount ID */
+	WORD	id;				/* Hosting volume mount ID */
 	BYTE	attr;			/* Object attribute */
 	BYTE	stat;			/* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:fragmented in this session, b2:sub-directory stretched) */
 	DWORD	sclust;			/* Object data start cluster (0:no cluster or root directory) */
@@ -248,7 +250,7 @@ typedef struct {
 	WORD	ftime;			/* Modified time */
 	BYTE	fattrib;		/* File attribute */
 #if FF_USE_LFN
-	TCHAR	altname[FF_SFN_BUF + 1];/* Alternative file name */
+	TCHAR	altname[FF_SFN_BUF + 1];/* Altenative file name */
 	TCHAR	fname[FF_LFN_BUF + 1];	/* Primary file name */
 #else
 	TCHAR	fname[12 + 1];	/* File name */
@@ -296,10 +298,8 @@ typedef enum {
 
 
 
-
-/*--------------------------------------------------------------*/
-/* FatFs Module Application Interface                           */
 /*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
 
 FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
 FRESULT f_close (FIL* fp);											/* Close an open file object */
@@ -336,8 +336,6 @@ int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
 int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
 TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the file */
 
-/* Some API fucntions are implemented as macro */
-
 #define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
 #define f_error(fp) ((fp)->err)
 #define f_tell(fp) ((fp)->fptr)
@@ -351,43 +349,38 @@ TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the fil
 
 
 /*--------------------------------------------------------------*/
-/* Additional Functions                                         */
-/*--------------------------------------------------------------*/
+/* Additional user defined functions                            */
 
-/* RTC function (provided by user) */
+/* RTC function */
 #if !FF_FS_READONLY && !FF_FS_NORTC
-DWORD get_fattime (void);	/* Get current time */
+DWORD get_fattime (void);
 #endif
 
-
-/* LFN support functions (defined in ffunicode.c) */
-
-#if FF_USE_LFN >= 1
+/* LFN support functions */
+#if FF_USE_LFN >= 1						/* Code conversion (defined in unicode.c) */
 WCHAR ff_oem2uni (WCHAR oem, WORD cp);	/* OEM code to Unicode conversion */
 WCHAR ff_uni2oem (DWORD uni, WORD cp);	/* Unicode to OEM code conversion */
 DWORD ff_wtoupper (DWORD uni);			/* Unicode upper-case conversion */
 #endif
-
-
-/* O/S dependent functions (samples available in ffsystem.c) */
-
 #if FF_USE_LFN == 3						/* Dynamic memory allocation */
 void* ff_memalloc (UINT msize);			/* Allocate memory block */
 void ff_memfree (void* mblock);			/* Free memory block */
 #endif
-#if FF_FS_REENTRANT	/* Sync functions */
-int ff_mutex_create (int vol);		/* Create a sync object */
-void ff_mutex_delete (int vol);		/* Delete a sync object */
-int ff_mutex_take (int vol);		/* Lock sync object */
-void ff_mutex_give (int vol);		/* Unlock sync object */
+
+/* Sync functions */
+#if FF_FS_REENTRANT
+int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj);	/* Create a sync object */
+int ff_req_grant (FF_SYNC_t sobj);		/* Lock sync object */
+void ff_rel_grant (FF_SYNC_t sobj);		/* Unlock sync object */
+int ff_del_syncobj (FF_SYNC_t sobj);	/* Delete a sync object */
 #endif
 
 
 
 
 /*--------------------------------------------------------------*/
-/* Flags and Offset Address                                     */
-/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
 
 /* File access mode and open method flags (3rd argument of f_open) */
 #define	FA_READ				0x01

stm-firmware/updater/ram-code/include/fatfs/ffconf.h

@@ -1,8 +1,8 @@
 /*---------------------------------------------------------------------------/
-/  Configurations of FatFs Module
+/  FatFs Functional Configurations
 /---------------------------------------------------------------------------*/
 
-#define FFCONF_DEF	80286	/* Revision ID */
+#define FFCONF_DEF	86631	/* Revision ID */
 
 /*---------------------------------------------------------------------------/
 / Function Configurations
@@ -68,7 +68,7 @@
 /   2: Enable with LF-CRLF conversion.
 /
 /  FF_PRINT_LLI = 1 makes f_printf() support long long argument and FF_PRINT_FLOAT = 1/2
-/  makes f_printf() support floating point argument. These features want C99 or later.
+   makes f_printf() support floating point argument. These features want C99 or later.
 /  When FF_LFN_UNICODE >= 1 with LFN enabled, string functions convert the character
 /  encoding in it. FF_STRF_ENCODE selects assumption of character encoding ON THE FILE
 /  to be read/written via those functions.
@@ -178,7 +178,7 @@
 /  logical drives. Number of items must not be less than FF_VOLUMES. Valid
 /  characters for the volume ID strings are A-Z, a-z and 0-9, however, they are
 /  compared in case-insensitive. If FF_STR_VOLUME_ID >= 1 and FF_VOLUME_STRS is
-/  not defined, a user defined volume string table is needed as:
+/  not defined, a user defined volume string table needs to be defined as:
 /
 /  const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
 */
@@ -190,7 +190,7 @@
 /  number and only an FAT volume found on the physical drive will be mounted.
 /  When this function is enabled (1), each logical drive number can be bound to
 /  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
-/  function will be available. */
+/  funciton will be available. */
 
 
 #define FF_MIN_SS		512
@@ -240,10 +240,10 @@
 #define FF_FS_NORTC		0
 #define FF_NORTC_MON	1
 #define FF_NORTC_MDAY	1
-#define FF_NORTC_YEAR	2022
-/* The option FF_FS_NORTC switches timestamp feature. If the system does not have
-/  an RTC or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable the
-/  timestamp feature. Every object modified by FatFs will have a fixed timestamp
+#define FF_NORTC_YEAR	2020
+/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
+/  any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
+/  the timestamp function. Every object modified by FatFs will have a fixed timestamp
 /  defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
 /  To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
 /  added to the project to read current time form real-time clock. FF_NORTC_MON,
@@ -253,7 +253,7 @@
 
 #define FF_FS_NOFSINFO	0
 /* If you need to know correct free space on the FAT32 volume, set bit 0 of this
-/  option, and f_getfree() function at the first time after volume mount will force
+/  option, and f_getfree() function at first time after volume mount will force
 /  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
 /
 /  bit0=0: Use free cluster count in the FSINFO if available.
@@ -275,21 +275,26 @@
 /      lock control is independent of re-entrancy. */
 
 
+/* #include <somertos.h>	// O/S definitions */
 #define FF_FS_REENTRANT	0
 #define FF_FS_TIMEOUT	1000
+#define FF_SYNC_t		HANDLE
 /* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
 /  module itself. Note that regardless of this option, file access to different
 /  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
 /  and f_fdisk() function, are always not re-entrant. Only file/directory access
-/  to the same volume is under control of this featuer.
+/  to the same volume is under control of this function.
 /
-/   0: Disable re-entrancy. FF_FS_TIMEOUT have no effect.
+/   0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
 /   1: Enable re-entrancy. Also user provided synchronization handlers,
-/      ff_mutex_create(), ff_mutex_delete(), ff_mutex_take() and ff_mutex_give()
-/      function, must be added to the project. Samples are available in ffsystem.c.
+/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
+/      function, must be added to the project. Samples are available in
+/      option/syscall.c.
 /
-/  The FF_FS_TIMEOUT defines timeout period in unit of O/S time tick.
-*/
+/  The FF_FS_TIMEOUT defines timeout period in unit of time tick.
+/  The FF_SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
+/  SemaphoreHandle_t and etc. A header file for O/S definitions needs to be
+/  included somewhere in the scope of ff.h. */
 
 
 

stm-firmware/version.c

@@ -1,27 +0,0 @@
-/* Reflow Oven Controller
- *
- * Copyright (C) 2022  Mario Hüttel <mario.huettel@gmx.net>
- *
- * This file is part of the Reflow Oven Controller Project.
- *
- * The reflow oven controller is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with the reflow oven controller project.
- * If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <reflow-controller/version.h>
-#include <generated-version/version.h>
-
-const char *version_git_version_string = GIT_VERSION_STRING;
-const char *version_git_full_commit_string = GIT_FULL_COMMIT;
-const char *version_compile_date = __DATE__;
-const char *version_compile_time = __TIME__;

temp-profile-checker/.gitignore

@@ -1,2 +0,0 @@
-*.o
-build/*

temp-profile-checker/CMakeLists.txt

@@ -1,41 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-project(tprcc LANGUAGES CXX)
-
-set (CMAKE_CXX_STANDARD 17)
-
-aux_source_directory("src" SRC_DIR)
-
-set (SRC_GENERATED "${CMAKE_CURRENT_BINARY_DIR}/tpr-parser.cpp" "${CMAKE_CURRENT_BINARY_DIR}/tpr-scanner.cpp")
-
-set (SOURCES
-	${SRC_DIR}
-	${SRC_GENERATED}
-)
-
-add_custom_command(
-	DEPENDS
-		${CMAKE_CURRENT_SOURCE_DIR}/parser/tpr.l
-	OUTPUT
-		${CMAKE_CURRENT_BINARY_DIR}/tpr-scanner.cpp
-	COMMAND
-		flex -+ -o "${CMAKE_CURRENT_BINARY_DIR}/tpr-scanner.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/parser/tpr.l"
-)
-
-add_custom_command(
-	DEPENDS
-		${CMAKE_CURRENT_SOURCE_DIR}/parser/tpr.ypp
-	OUTPUT
-		${CMAKE_CURRENT_BINARY_DIR}/tpr-parser.cpp
-	COMMAND
-		mkdir -p "${CMAKE_CURRENT_BINARY_DIR}/generated" && bison -o"${CMAKE_CURRENT_BINARY_DIR}/tpr-parser.cpp" --header="${CMAKE_CURRENT_BINARY_DIR}/generated/tpr-parser.hpp" "${CMAKE_CURRENT_SOURCE_DIR}/parser/tpr.ypp"
-)	
-
-
-
-SET_SOURCE_FILES_PROPERTIES(${SRC_GENERATED} PROPERTIES GENERATED 1)
-add_executable(${PROJECT_NAME} ${SOURCES})
-
-target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/generated")
-target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
-# TEMPORARY FIx:
-target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")

temp-profile-checker/include/tpr/tpr-scanner.hpp

@@ -1,38 +0,0 @@
-#ifndef _TPR_SCANNER_HPP_
-#define _TPR_SCANNER_HPP_
-
-
-#if ! defined(yyFlexLexerOnce)
-#include <FlexLexer.h>
-#endif
-
-#include "tpr-parser.hpp"
-#include "location.hh"
-
-namespace tpr {
-
-class TempProfileScanner : public yyFlexLexer{
-  public:
-
-    TempProfileScanner(std::istream *in) : yyFlexLexer(in) {
-    };
-    virtual ~TempProfileScanner() {};
-
-    //get rid of override virtual function warning
-    using FlexLexer::yylex;
-
-    virtual
-      int yylex( tpr::TempProfileParser::semantic_type * const lval, 
-          tpr::TempProfileParser::location_type *location );
-    // YY_DECL defined in mc_lexer.l
-    // Method body created by flex in mc_lexer.yy.cc
-
-  private:
-    /* yyval ptr */
-    tpr::TempProfileParser::semantic_type *yylval = nullptr;
-};
-
-} /* end namespace MC */
-
-
-#endif /* _TPR_SCANNER_HPP_ */

temp-profile-checker/parser/Makefile

@@ -0,0 +1,43 @@
+LEXER := flex
+YACC := bison
+CC := gcc
+
+YACC_FLAGS := -yd
+LEXER_FLAGS := 
+
+LANG_NAME := lang
+
+
+ifneq ($(VERBOSE),true)
+QUIET=@
+else
+QUIET=
+endif
+
+default: test
+
+y.tab.c: $(LANG_NAME).yacc
+	$(QUIET)echo "[$(YACC)] $@"
+	$(QUIET)$(YACC) $(YACC_FLAGS) $<
+	
+lex.yy.c: $(LANG_NAME).lex
+	$(QUIET)echo "[$(LEXER)] $@"
+	$(QUIET)$(LEXER) $^
+
+test: y.tab.c lex.yy.c
+	$(QUIET)echo "[CC] $@"
+	$(QUIET)$(CC) -o $@ $^
+	
+	
+
+.PHONY: clean run
+
+run: test
+	./test
+
+clean:
+	$(QUIET)echo "Clean up..."
+	$(QUIET)rm -f *.c *.o y.tab.h test
+
+
+

temp-profile-checker/parser/lang.lex

@@ -0,0 +1,45 @@
+%{
+#include <stdio.h>
+#include "y.tab.h"
+%}
+
+/*
+static const struct pl_command_list_map cmd_list_map[_PL_NUM_CMDS] = {
+	{PL_PID_CONF, "pid_conf", 6u},
+	{PL_SET_TEMP, "temp_set", 1u},
+	{PL_WAIT_FOR_TEMP, "wait_temp", 1u},
+	{PL_WAIT_FOR_TIME, "wait_time", 1u},
+	{PL_SET_RAMP, "temp_ramp", 2u},
+	{PL_LOUDSPEAKER_SET, "beep", 1u},
+	{PL_OFF, "temp_off", 0u},
+	{PL_CLEAR_FLAGS, "clear_flags", 0u},
+	{PL_DIGIO_CONF, "digio_conf", 2u},
+	{PL_DIGIO_SET, "digio_set", 2u},
+	{PL_DIGIO_WAIT, "digio_wait", 2u},
+};
+*/
+
+%option yylineno
+
+%%
+
+#[^\n]* return COMMENT;
+pid_conf return PL_PID_CONF;
+temp_set return PL_SET_TEMP;
+wait_temp return PL_WAIT_FOR_TEMP;
+wait_time return PL_WAIT_FOR_TIME;
+temp_ramp return PL_SET_RAMP;
+beep return PL_LOUDSPEAKER_SET;
+temp_off return PL_OFF;
+clear_flags return PL_CLEAR_FLAGS;
+digio_conf return PL_DIGIO_CONF;
+digio_set return PL_DIGIO_SET;
+digio_wait return PL_DIGIO_WAIT;
+[+-]?[0-9]+ yylval.int_value=atoi(yytext); return INT_NUMBER;
+[+-]?[0-9]+[.]?[0-9]* yylval.float_value=atof(yytext); return NUMBER;
+[ \t]+ /* Ignore whitespaces */;
+[\r]?\n return NEWLINE;
+
+[^\t\n #]+ return LITERAL;
+
+%%

temp-profile-checker/parser/lang.yacc

@@ -0,0 +1,137 @@
+%{
+#include <stdio.h>
+#include <string.h>
+
+extern int yylineno;
+extern int yylex();
+extern int yyparse();
+
+void yyerror(const char *str)
+{
+	fprintf(stderr, "Error: %s, line %d\n", str, yylineno);
+}
+
+int yywrap()
+{
+        return 1;
+} 
+  
+int main()
+{
+        yyparse();
+        return 0;
+} 
+
+%}
+
+%locations
+
+%token COMMENT PL_PID_CONF PL_SET_TEMP PL_WAIT_FOR_TEMP PL_WAIT_FOR_TIME PL_SET_RAMP PL_LOUDSPEAKER_SET PL_OFF PL_CLEAR_FLAGS PL_DIGIO_CONF PL_DIGIO_SET PL_DIGIO_WAIT NEWLINE LITERAL
+%token <float_value> NUMBER
+%token <int_value> INT_NUMBER
+
+%type <float_value> any_num
+
+%union
+{
+    int int_value;
+    float float_value;
+}
+
+%%
+
+program: /* empty */
+	| program command
+	| program NEWLINE
+	| program cmt_line
+	;
+
+command:
+	command_core NEWLINE
+	|
+	command_core cmt_line
+	;
+	
+command_core:
+	pid_conf | temp_set | wait_time | wait_temp | temp_ramp | beep | temp_off | clear_flags | digio_conf | digio_set | digio_wait;
+	
+pid_conf: PL_PID_CONF any_num any_num any_num any_num any_num any_num
+	{
+		printf("PID Config\n");
+	} 
+	;
+
+temp_set: PL_SET_TEMP any_num
+	{
+		printf("Target temp set: %f\n", $2);
+	}
+	;
+	
+wait_time: PL_WAIT_FOR_TIME any_num
+	{
+		printf("Wait for %f seconds\n", $2);
+	}
+	;
+
+wait_temp: PL_WAIT_FOR_TEMP any_num
+	{
+		printf("Wait for temperature %f\n", $2);
+	}
+	;
+	
+temp_ramp: PL_SET_RAMP any_num any_num
+	{
+		printf("Temperature ramp. Target %f, duration: %f\n", $2, $3);
+	}
+	;
+	
+cmt_line: COMMENT NEWLINE
+	{
+		printf("Comment line detected\n");
+	};
+	
+beep: PL_LOUDSPEAKER_SET INT_NUMBER
+	{
+		printf("Beep: %d\n", $2);
+	}
+	|
+	PL_LOUDSPEAKER_SET NUMBER
+	{
+		printf("Warning: Float value casted to int!\n");
+		printf("Beep %u\n", (unsigned int)$2);
+	};
+
+temp_off: PL_OFF
+	{
+		printf("Turn off oven\n");
+	}
+	;
+	
+clear_flags: PL_CLEAR_FLAGS
+	{
+		printf("Clear flags\n");
+	}
+	;
+
+digio_conf: PL_DIGIO_CONF INT_NUMBER INT_NUMBER
+	{
+		printf("Configure digio pin\n");
+	};
+	
+digio_set: PL_DIGIO_SET INT_NUMBER INT_NUMBER
+	{
+		printf("Configure digio pin\n");
+	};
+	
+digio_wait: PL_DIGIO_WAIT INT_NUMBER INT_NUMBER
+	{
+		printf("Configure digio pin\n");
+	};
+
+/* Matches any number format that can be interpreted as float */	
+any_num : NUMBER | INT_NUMBER
+	{
+		$$ = (float)$1;
+	};
+%%
+

temp-profile-checker/parser/tpr.l

@@ -1,26 +0,0 @@
-%{
-#include <tpr/tpr-scanner.hpp>
-#undef  YY_DECL
-#define YY_DECL int tpr::TempProfileScanner::yylex(tpr::TempProfileParser::semantic_type * const lval, tpr::TempProfileParser::location_type *loc )
-
-#define YY_USER_ACTION loc->step(); loc->columns(yyleng);
-
-%}
-
-%option yyclass="tpr::TempProgileScanner"
-%option noyywrap
-%option never-interactive
-%option c++
-
-/* Predefined rules */
-NEWLINE         "\n"|"\r\n"
-SPACE           " "|"\t"|"\f"
-COMMENT_BEGIN   "/*"
-COMMENT_END     "*/" 
-COMMENT_LINE  "//".*\n
-
-%%
-
-SPACE {return 0;}
-
-%%

temp-profile-checker/parser/tpr.ypp

@@ -1,48 +0,0 @@
-
-%language "c++"
-%require  "3.2"
-%defines 
-%define api.namespace {tpr}
-%define api.parser.class {TempProfileParser}
-
-%define parse.error verbose
-
-%code requires{
-  namespace tpr {
-    class TempProfileScanner;
-}
-}
-
-%parse-param { TempProfileScanner &scanner }
-
-%code {
-	#include <iostream>
-	#include <cstdlib>
-	#include <fstream>
-	#include <utility>
-	#include <tuple>
-	#include <tpr/tpr-scanner.hpp>
-	#undef yylex
-	#define yylex scanner.yylex
-}
-
-%define api.value.type variant
-%locations
-%start tpr_file
-
-%token foo
-
-%%
-
-tpr_file: foo
-	| tpr_file foo
-	;
-
-
-%%
-
-void tpr::TempProfileParser::error(const location_type &l, const std::string &err_message)
-{
-	std::cerr << "Error " << err_message << " at " << l << std::endl;
-	std::abort();
-}

temp-profile-checker/src/main.cpp

@@ -1,8 +0,0 @@
-#include <iostream>
-
-int main(int argc, char **argv)
-{
-	std::cout << "Hello world" << std::endl;
-
-	return 0;
-}