GUI: About menu: Add '[DEBUG]' text if code is build in debug mode

* Make Systick a 100us Timer. Millisecond ticks are still untouched.
* LCD now has a 100us resolution tick
* LCD uses 500us delay for waitstate
* Make 'About' menu verbose:
	* Add 3 page menu
	* 1st page: Generic info
	* 2nd page: Version info
	* 3rd page: Uptime in seconds

.gitmodules

@@ -1,3 +1,11 @@
 [submodule "stm-firmware/shellmatta"]
 	path = stm-firmware/shellmatta
 	url = https://git.shimatta.de/mhu/shellmatta
+[submodule "c-style-checker"]
+	path = c-style-checker
+	url = https://git.shimatta.de/mhu/c-style-checker.git
+	branch = master
+[submodule "reflow-controller-temp-profile-lang"]
+	path = reflow-controller-temp-profile-lang
+	url = https://git.shimatta.de/mhu/reflow-controller-temp-profile-lang.git
+	branch = master

measurement-data/Analog_Measurement_Analysis.ipynb

@@ -351,7 +351,8 @@
     "                    (kilo_ohm_sampling1_ht, 'Day 1 Sampling -- Stable circuit -- HT'),\n",
     "                    (kilo_ohm_sampling2, 'Day 2 Sampling -- Stable circuit'),\n",
     "                    (pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay3.csv'), 'Day 3 Sampling -- Stable Circuit (improved)'),\n",
-    "                    (pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay4.csv'), 'Day 4 Sampling -- Stable Circuit (improved)')\n",
+    "                    (pd.read_csv(r'1000OhmSamplingFixedStableCircuitDay4.csv'), 'Day 4 Sampling -- Stable Circuit (improved)'),\n",
+    "                    (pd.read_csv(r'1000OhmSampling-v1.2.csv'), 'Day 1 Sampling v1.2')\n",
     "                   ]\n"
    ]
   },
@@ -390,7 +391,12 @@
    "outputs": [],
    "source": [
     "print(calc_temp(1000.6)-calc_temp(1000.4))\n",
-    "print(1/4096*2500)"
+    "\n",
+    "adc_min_res = 1/4095*2500\n",
+    "print('Min res: ', adc_min_res)\n",
+    "\n",
+    "print(calc_temp(2000))\n",
+    "print(calc_temp(2000+adc_min_res))"
    ]
   }
  ],
@@ -410,7 +416,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.1"
+   "version": "3.8.2"
   }
  },
  "nbformat": 4,

stm-firmware/.gitignore

@@ -8,3 +8,9 @@ reflow-controller.cxxflags
 reflow-controller.files
 reflow-controller.includes
 *.creator.user
+*.cflags
+*.creator
+*.cxxflags
+*.includes
+*.config
+*.files

stm-firmware/Makefile

@@ -5,15 +5,15 @@
 #Add Files and Folders below#########################################################
 CFILES 	= main.c syscalls.c setup/system_stm32f4xx.c systick.c
 ASFILES = boot/startup_stm32f4xx.S
-INCLUDEPATH = -Icmsis -Iinclude
+INCLUDEPATH = -Iinclude
 
-OBJDIR = obj
+OBJDIR_BASE = obj
-target	= reflow-controller
+TARGET_BASE = reflow-controller
 LIBRARYPATH = -L. -Lmathlib
 LIBRARIES = -larm_cortexM4lf_math -lm
 
 DEFINES = -DSTM32F407xx -DSTM32F4XX -DARM_MATH_CM4 -DHSE_VALUE=8000000UL
-mapfile = memory-mapping
+MAPFILE_BASE = memory-mapping
 
 export GIT_VER = $(shell git describe --always --dirty --tags)
 DEFINES += -DGIT_VER=$(GIT_VER)
@@ -28,41 +28,72 @@ endif
 CFILES += adc-meas.c
 
 # Shellmatta
-CFILES += shellmatta/src/shellmatta.c shellmatta/src/shellmatta_autocomplete.c shellmatta/src/shellmatta_escape.c shellmatta/src/shellmatta_history.c shellmatta/src/shellmatta_utils.c shell.c
+CFILES += shellmatta/src/shellmatta.c shellmatta/src/shellmatta_autocomplete.c shellmatta/src/shellmatta_escape.c shellmatta/src/shellmatta_history.c shellmatta/src/shellmatta_utils.c shellmatta/src/shellmatta_opt.c shell.c
 INCLUDEPATH += -Ishellmatta/api
-# DEFINES += -DSHELLMATTA_STRIP_PRINTF
+DEFINES += -DSHELLMATTA_HELP_ALIAS=\"?\"
 
 # RCC Manager
 CFILES += stm-periph/clock-enable-manager.c
-
 CFILES += stm-periph/uart.c stm-periph/dma-ring-buffer.c
-
 CFILES += digio.c
-
 CFILES += stm-periph/unique-id.c
-
 CFILES += calibration.c
-
 CFILES += temp-converter.c
+CFILES += rotary-encoder.c button.c
+CFILES += stack-check.c
+CFILES += ui/lcd.c ui/menu.c reflow-menu.c
+#CFILES += onewire-temp-sensors.c
+CFILES += fatfs/diskio.c fatfs/ff.c fatfs/ffsystem.c fatfs/ffunicode.c fatfs/shimatta_sdio_driver/shimatta_sdio.c
+CFILES += pid-controller.c oven-driver.c
+CFILES += settings/settings.c settings/settings-sd-card.c
+CFILES += safety-adc.c
 
-CFILES += rotary-encoder.c
+DEBUG_DEFINES = -DDEBUGBUILD
-
+RELEASE_DEFINES = 
-DEFINES += -DDEBUGBUILD
-#TODO
 
 ###################################################################################
-CC=arm-none-eabi-gcc
+ifeq ($(CROSS_COMPILE),)
-OBJCOPY=arm-none-eabi-objcopy
+CROSS_COMPILE=arm-none-eabi-
-OBJDUMP=arm-none-eabi-objdump
+endif
-SIZE=arm-none-eabi-size
 
-LFLAGS = -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork
+CC=$(CROSS_COMPILE)gcc
+OBJCOPY=$(CROSS_COMPILE)objcopy
+OBJDUMP=$(CROSS_COMPILE)objdump
+SIZE=$(CROSS_COMPILE)size
+
+CFLAGS_RELEASE = -O3 -g
+CFLAGS_DEBUG = -O0 -g
+
+LFLAGS_RELEASE = -Wl,--gc-sections
+LFLAGS_DEBUG =
+
+CFLAGS =
+LFLAGS =
+
+ifneq ($(DEBUGBUILD),true)
+DEFINES += $(RELEASE_DEFINES)
+CFLAGS += $(CFLAGS_RELEASE)
+LFLAGS += $(LFLAGS_RELEASE)
+target = $(TARGET_BASE)-release
+OBJDIR = $(OBJDIR_BASE)/release
+MAPFILE = $(MAPFILE_BASE)-release
+else
+DEFINES += $(DEBUG_DEFINES)
+target = $(TARGET_BASE)-debug
+CFLAGS += $(CFLAGS_DEBUG)
+LFLAGS += $(LFLAGS_DEBUG)
+OBJDIR = $(OBJDIR_BASE)/debug
+MAPFILE = $(MAPFILE_BASE)-debug
+endif
+
+LFLAGS += -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork
 LFLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16 --disable-newlib-supplied-syscalls -nostartfiles
-LFLAGS += -Tstm32f407vet6_flash.ld -Wl,-Map=$(mapfile).map
+LFLAGS += -Tstm32f407vet6_flash.ld -Wl,-Map=$(MAPFILE).map
 
-CFLAGS = -c -fmessage-length=0 -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork
+CFLAGS += -c -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork
-CFLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles -O0 -g
+CFLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles
 CFLAGS += -Wall -Wextra -Wold-style-declaration -Wuninitialized -Wmaybe-uninitialized -Wunused-parameter -Wimplicit-fallthrough=3 -Wsign-compare
+
 ####################################################################################
 
 OBJ = $(CFILES:%.c=$(OBJDIR)/%.c.o)
@@ -70,12 +101,19 @@ ASOBJ += $(ASFILES:%.S=$(OBJDIR)/%.S.o)
 
 default: $(target).elf
 
+all: debug release
+
+release:
+	$(QUIET)$(MAKE) DEBUGBUILD=false
+
+debug:
+	$(QUIET)$(MAKE) DEBUGBUILD=true
+
 %.bin: %.elf
 	$(QUIET)$(OBJCOPY) -O binary $^ $@
 %.hex: %.elf
 	$(QUIET)$(OBJCOPY) -O ihex $^ $@
 
-
 #Linking
 $(target).elf: $(OBJ) $(ASOBJ)
 	@echo [LD] $@
@@ -93,10 +131,16 @@ $(ASOBJ):
 	@echo [AS] $@
 	$(eval OUTPATH=$(dir $@))
 	@mkdir -p $(OUTPATH)
-	$(QUIET)$(CC) $(CFLAGS) -MMD -MT $@ $(INCLUDEPATH) $(DEFINES) -o $@ $(@:$(OBJDIR)/%.S.o=%.S)	
+	$(QUIET)$(CC) $(CFLAGS) -MMD -MT $@ $(INCLUDEPATH) $(DEFINES) -o $@ $(@:$(OBJDIR)/%.S.o=%.S)
 
 
-.PHONY: qtproject clean mrproper objcopy disassemble
+.PHONY: qtproject-legacy qtproject qtproject-debug clean mrproper objcopy disassemble program program-debug
+
+program-debug:
+	$(QUIET)$(MAKE) DEBUGBUILD=true program
+
+program: $(target).elf
+	./program-device.sh $<
 
 disassemble: $(target).elf
 	$(QUIET)$(OBJDUMP) -D -s $< > $(target).lss
@@ -104,11 +148,23 @@ disassemble: $(target).elf
 objcopy: $(target).bin $(target).hex
 
 mrproper: clean
-	rm -f $(target).pro
+	@echo "Purging project files..."
+	$(QUIET)rm -f $(target).pro $(target).creator $(target).files $(target).cflags $(target).cxxflags $(target).includes $(target).config
 
 clean:
-	rm -f $(target).elf $(target).bin $(target).hex $(OBJ) $(ASOBJ) $(mapfile).map $(CFILES:%.c=$(OBJDIR)/%.c.d) $(ASFILES:%.S=$(OBJDIR)/%.S.d)
+	@echo -n "Cleaning up derived files for "
-qtproject:
+ifneq ($(DEBUGBUILD),true)
+	@echo "RELEASE build"
+else
+	@echo "DEBUG build"
+endif
+	$(QUIET)rm -f $(target).elf $(target).bin $(target).hex $(OBJ) $(ASOBJ) $(mapfile).map $(CFILES:%.c=$(OBJDIR)/%.c.d) $(ASFILES:%.S=$(OBJDIR)/%.S.d) 
+	$(QUIET)rm -rf $(OBJDIR)/*
+ifneq ($(DEBUGBUILD),true)
+	$(QUIET)$(MAKE) DEBUGBUILD=true clean
+endif
+
+qtproject-legacy:
 	echo -e "TEMPLATE = app\nCONFIG -= console app_bundle qt" > $(target).pro
 	echo -e "SOURCES += $(CFILES) $(ASFILES)" >> $(target).pro
 	echo -ne "INCLUDEPATH += " >> $(target).pro
@@ -118,4 +174,26 @@ qtproject:
 	echo -ne "\nDEFINES += " >> $(target).pro
 	echo "$(DEFINES)" | sed "s/-D//g" >> $(target).pro
 
+qtproject-debug:
+	@echo "Generating debug build project"
+	$(QUIET)$(MAKE) DEBUGBUILD=true qtproject
+
+qtproject:
+	$(QUIET)rm -f $(target).files $(target).cflags $(target).config $(target).creator $(target).includes $(target).creator.user
+	@echo "Generating source file list"
+	$(QUIET)echo "$(CFILES)" | tr ' ' '\n' > $(target).files
+	@echo -n "Appending found header files from folders "
+	@echo `echo $(INCLUDEPATH) | sed "s/-I//g"`
+	$(QUIET)for dir in `echo $(INCLUDEPATH) | sed "s/-I//g"`; do \
+		find `echo "$${dir}"` -name "*.h" >> $(target).files; \
+	done
+	@echo "Generating $(target).cflags"
+	$(QUIET)echo "" > $(target).cflags
+	@echo "Generating $(target).includes"
+	$(QUIET)echo $(INCLUDEPATH) | sed "s/-I/,/g" | tr , '\n' | sed "/^$$/d" > $(target).includes;
+	@echo "Generating $(target).config"
+	$(QUIET)echo $(DEFINES) | sed "s/-D/,#define /g" | tr , '\n' | sed "/^$$/d" > $(target).config
+	@echo "Generating $(target).creator"
+	$(QUIET)echo "[GENERAL]" > $(target).creator
+
 -include $(CFILES:%.c=$(OBJDIR)/%.c.d) $(ASFILES:%.S=$(OBJDIR)/%.S.d)

stm-firmware/adc-meas.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -36,6 +36,7 @@ static volatile int * volatile streaming_flag_ptr = NULL;
 static uint32_t filter_startup_cnt;
 static volatile float adc_pt1000_raw_reading_hf;
 static volatile uint16_t dma_sample_buffer[ADC_PT1000_DMA_AVG_SAMPLES];
+static volatile uint32_t adc_watchdog_counter = 0UL;
 
 volatile float * volatile stream_buffer = NULL;
 volatile uint32_t stream_count;
@@ -69,12 +70,12 @@ static inline void adc_pt1000_setup_sample_frequency_timer()
 
 static inline void adc_pt1000_disable_adc()
 {
-	ADC1->CR2 &= ~ADC_CR2_ADON;
+	ADC_PT1000_PERIPH->CR2 &= ~ADC_CR2_ADON;
 	DMA2_Stream0->CR = 0;
 
 	pt1000_error |= ADC_PT1000_INACTIVE;
 
-	rcc_manager_disable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(RCC_APB2ENR_ADC1EN));
+	rcc_manager_disable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(RCC_APB2ENR_ADC3EN));
 	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(ADC_PT1000_PORT_RCC_MASK));
 }
 
@@ -98,7 +99,7 @@ static inline void adc_pt1000_enable_dma_stream()
 	DMA2_Stream0->M0AR = (uint32_t)dma_sample_buffer;
 
 	/* Source is the ADC data register */
-	DMA2_Stream0->PAR = (uint32_t)&ADC1->DR;
+	DMA2_Stream0->PAR = (uint32_t)&ADC_PT1000_PERIPH->DR;
 
 	/* Transfer size is ADC_PT1000_DMA_AVG_SAMPLES */
 	DMA2_Stream0->NDTR = ADC_PT1000_DMA_AVG_SAMPLES;
@@ -111,7 +112,7 @@ static inline void adc_pt1000_enable_dma_stream()
 	 * Todo: Maybe use twice as big of a buffer and also use half-fill interrupt in order to prevent overruns
 	 */
 	DMA2_Stream0->CR = DMA_SxCR_PL_1 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PSIZE_0 | DMA_SxCR_MINC |
-			DMA_SxCR_CIRC | DMA_SxCR_TCIE | DMA_SxCR_TEIE | DMA_SxCR_EN;
+			DMA_SxCR_CIRC | DMA_SxCR_TCIE | DMA_SxCR_TEIE | DMA_SxCR_EN | ((ADC_PT1000_CHANNEL  & 0x7)<<25);
 }
 
 static inline void adc_pt1000_disable_dma_stream()
@@ -128,32 +129,32 @@ static inline void adc_pt1000_disable_dma_stream()
 
 void adc_pt1000_setup_meas()
 {
-	rcc_manager_enable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(RCC_APB2ENR_ADC1EN));
+	rcc_manager_enable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(RCC_APB2ENR_ADC3EN));
 	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(ADC_PT1000_PORT_RCC_MASK));
 
 	ADC_PT1000_PORT->MODER |= ANALOG(ADC_PT1000_PIN);
 
 	/* Set S&H time for PT1000 ADC channel */
 #if ADC_PT1000_CHANNEL < 10
-	ADC1->SMPR2 |= (7U << (3*ADC_PT1000_CHANNEL));
+	ADC_PT1000_PERIPH->SMPR2 |= (7U << (3*ADC_PT1000_CHANNEL));
 #else
-	ADC1->SMPR1 |= (7U << (3*(ADC_PT1000_CHANNEL-10)));
+	ADC_PT1000_PERIPH->SMPR1 |= (7U << (3*(ADC_PT1000_CHANNEL-10)));
 #endif
 
-	ADC->CCR |= (0x2<<16);
+	ADC->CCR |= (0x3<<16);
 
 	/* Set watchdog limits */
-	ADC1->HTR = ADC_PT1000_UPPER_WATCHDOG;
+	ADC_PT1000_PERIPH->HTR = ADC_PT1000_UPPER_WATCHDOG;
-	ADC1->LTR = ADC_PT1000_LOWER_WATCHDOG;
+	ADC_PT1000_PERIPH->LTR = ADC_PT1000_LOWER_WATCHDOG;
 
 	/* Set length of sequence to 1 */
-	ADC1->SQR1 = (0UL<<20);
+	ADC_PT1000_PERIPH->SQR1 = (0UL<<20);
 
 	/* Set channel as 1st element in sequence */
-	ADC1->SQR3 = (ADC_PT1000_CHANNEL<<0);
+	ADC_PT1000_PERIPH->SQR3 = (ADC_PT1000_CHANNEL<<0);
 
-	ADC1->CR1 = ADC_CR1_OVRIE | ADC_CR1_AWDEN | ADC_CR1_AWDIE;
+	ADC_PT1000_PERIPH->CR1 = ADC_CR1_OVRIE | ADC_CR1_AWDEN | ADC_CR1_AWDIE;
-	ADC1->CR2 = ADC_CR2_EXTEN_0 | ADC_CR2_EXTSEL_2 | ADC_CR2_EXTSEL_1 | ADC_CR2_ADON | ADC_CR2_DMA | ADC_CR2_DDS;
+	ADC_PT1000_PERIPH->CR2 = ADC_CR2_EXTEN_0 | ADC_CR2_EXTSEL_2 | ADC_CR2_EXTSEL_1 | ADC_CR2_ADON | ADC_CR2_DMA | ADC_CR2_DDS;
 
 	adc_pt1000_set_moving_average_filter_param(ADC_PT1000_FILTER_WEIGHT);
 	adc_pt1000_set_resistance_calibration(0, 0, false);
@@ -323,18 +324,20 @@ void ADC_IRQHandler(void)
 {
 	uint32_t adc1_sr;
 
-	adc1_sr = ADC1->SR;
+	adc1_sr = ADC_PT1000_PERIPH->SR;
 
 	if (adc1_sr & ADC_SR_OVR) {
-		ADC1->SR &= ~ADC_SR_OVR;
+		ADC_PT1000_PERIPH->SR &= ~ADC_SR_OVR;
 		pt1000_error |= ADC_PT1000_OVERFLOW;
 		/* Disable ADC  in case of overrrun*/
 		adc_pt1000_disable();
 	}
 
 	if (adc1_sr & ADC_SR_AWD) {
-		ADC1->SR &= ~ADC_SR_AWD;
+		ADC_PT1000_PERIPH->SR &= ~ADC_SR_AWD;
-		pt1000_error |= ADC_PT1000_WATCHDOG_ERROR;
+		adc_watchdog_counter++;
+		if (adc_watchdog_counter >= ADC_PT1000_WATCHDOG_SAMPLE_COUNT)
+			pt1000_error |= ADC_PT1000_WATCHDOG_ERROR;
 	}
 }
 
@@ -369,6 +372,9 @@ void DMA2_Stream0_IRQHandler()
 		if (streaming_flag_ptr)
 			append_stream_buffer(adc_val);
 
+		if (adc_watchdog_counter > 0UL)
+			adc_watchdog_counter--;
+
 		/* Call moving average filter */
 		adc_pt1000_filter(adc_val);
 	}

stm-firmware/button.c

@@ -0,0 +1,97 @@
+/* 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/>.
+*/
+
+#include <stm32/stm32f4xx.h>
+#include <reflow-controller/button.h>
+#include <stm-periph/stm32-gpio-macros.h>
+#include <stm-periph/clock-enable-manager.h>
+#include <stdint.h>
+#include <cmsis/core_cm4.h>
+#include <reflow-controller/systick.h>
+
+static volatile uint64_t to_active_timestamp;
+static volatile enum button_state int_state;
+
+void button_init()
+{
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(BUTTON_RCC_MASK));
+	rcc_manager_enable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(RCC_APB2ENR_SYSCFGEN));
+	BUTTON_PORT->MODER &= MODER_DELETE(BUTTON_PIN);
+	BUTTON_PORT->PUPDR &= PUPDR_DELETE(BUTTON_PIN);
+	BUTTON_PORT->PUPDR |= PULLUP(BUTTON_PIN);
+
+	to_active_timestamp = 0ULL;
+	int_state = BUTTON_IDLE;
+
+	SYSCFG->EXTICR[1] |= 0x3;
+	EXTI->IMR |= (1U<<4);
+	EXTI->RTSR |= (1U<<4);
+	EXTI->FTSR |= (1U<<4);
+	NVIC_EnableIRQ(EXTI4_IRQn);
+}
+
+enum button_state button_read_event()
+{
+	uint64_t time_delta;
+	enum button_state temp_state;
+
+	if (BUTTON_PORT->IDR & (1U<<BUTTON_PIN)) {
+		temp_state = int_state;
+		int_state = BUTTON_IDLE;
+		return temp_state;
+	} else {
+		time_delta = systick_get_global_tick() - to_active_timestamp;
+		if (time_delta >= BUTTON_LONG_ON_TIME_MS)
+			return BUTTON_LONG;
+		else if (time_delta >= BUTTON_SHORT_ON_TIME_MS)
+			return BUTTON_SHORT;
+		else
+			return BUTTON_IDLE;
+	}
+}
+
+void button_deinit()
+{
+	BUTTON_PORT->MODER &= MODER_DELETE(BUTTON_PIN);
+	BUTTON_PORT->PUPDR &= PUPDR_DELETE(BUTTON_PIN);
+	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(BUTTON_RCC_MASK));
+	EXTI->IMR &= ~(1U<<4);
+	rcc_manager_disable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(RCC_APB2ENR_SYSCFGEN));
+}
+
+void EXTI4_IRQHandler(void)
+{
+	uint64_t time_delta;
+
+	/* Clear interrupts */
+	EXTI->PR = EXTI->PR;
+	__DSB();
+
+	if (BUTTON_PORT->IDR & (1U<<BUTTON_PIN)) {
+		time_delta = systick_get_global_tick() - to_active_timestamp;
+		if (time_delta >= BUTTON_SHORT_ON_TIME_MS && time_delta < BUTTON_LONG_ON_TIME_MS) {
+			int_state = BUTTON_SHORT_RELEASED;
+		} else if (time_delta >= BUTTON_LONG_ON_TIME_MS) {
+			int_state = BUTTON_LONG_RELEASED;
+		}
+	} else {
+		to_active_timestamp = systick_get_global_tick();
+	}
+}

stm-firmware/calibration.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -27,6 +27,8 @@
 #include <stdlib.h>
 #include <float.h>
 
+enum calibration_shell_state {CAL_START = 0, CAL_WAIT_RES1, CAL_MEAS_RES1, CAL_WAIT_RES2, CAL_MEAS_RES2};
+
 void calibration_calculate(float low_measured, float low_setpoint, float high_measured, float high_setpoint,
 			   float *sens_deviation, float *sens_corrected_offset)
 {
@@ -48,124 +50,217 @@ void calibration_calculate(float low_measured, float low_setpoint, float high_me
 
 
 
-int calibration_acquire_data(float *mu, float *max_dev, uint32_t count)
+float *calibration_acquire_data_start(uint32_t count, volatile int *flag)
 {
 	int status;
 	float *stream_mem;
-	float min_val = FLT_MAX;
-	float max_val = -FLT_MAX;
-	uint32_t i;
-	int ret_val = 0;
 
-	static volatile int flag = 0;
+	if (!count)
-
+		return NULL;
-	if (!mu || !max_dev || !count)
-		return -1000;
 
 	stream_mem = (float *)calloc(count, sizeof(float));
 	if (!stream_mem)
-		return -2;
+		return stream_mem;
 
-	status = adc_pt1000_stream_raw_value_to_memory(stream_mem, count, &flag);
+	*flag = 0;
+	status = adc_pt1000_stream_raw_value_to_memory(stream_mem, count, flag);
 	if (status)
-		return status;
+		goto free_mem;
 
-	/* Wait for data to be transferred */
-	while (flag == 0);
 
-	if (flag != 1) {
+	return stream_mem;
+free_mem:
+	free(stream_mem);
+	return NULL;
+}
+
+static int calibration_poll_data_acquisition(float *mem_array, uint32_t count, volatile int *flag, float *mu, float *max_dev)
+{
+	int ret_val = 0;
+	float min_val = FLT_MAX;
+	float max_val = -FLT_MAX;
+	uint32_t i;
+
+	if (!flag || !mem_array || !mu || !max_dev)
+		return -1000;
+
+	if (*flag == 0) {
+		/* Continue polling */
+		return 1;
+	}
+
+	if (*flag != 1) {
 		/* Error */
 		ret_val = -1;
 		goto ret_free_mem;
 	}
 
 	/* Convert the stream memory to Ohm readings */
-	adc_pt1000_convert_raw_value_array_to_resistance(NULL, stream_mem, count);
+	adc_pt1000_convert_raw_value_array_to_resistance(NULL, mem_array, count);
 
 	/* Do not compute std-deviation. Too imprecise
 	 * arm_std_f32(stream_mem, count, sigma);
 	 */
-	arm_mean_f32(stream_mem, count, mu);
+	arm_mean_f32(mem_array, count, mu);
 
 	/* Find min and max values of array */
 	for (i = 0U; i < count; i++) {
-		min_val = MIN(min_val, stream_mem[i]);
+		min_val = MIN(min_val, mem_array[i]);
-		max_val = MAX(max_val, stream_mem[i]);
+		max_val = MAX(max_val, mem_array[i]);
 	}
 
 	/* Compute maximum deviation range */
 	*max_dev = max_val - min_val;
 
 ret_free_mem:
-	free(stream_mem);
+	free(mem_array);
 	return ret_val;
 }
 
-static void wait_for_uart_enter()
+shellmatta_retCode_t calibration_sequence_shell_cmd(shellmatta_handle_t shell, const char *arg, uint32_t len)
 {
-	int enter_received = 0;
+	(void)arg;
-	const char *recv_data;
+	(void)len;
-	size_t recv_len;
-	size_t iter;
-	int uart_recv_status;
 
-	do {
+	/* This stores the current state of the calibration process */
-		uart_recv_status = uart_receive_data_with_dma(&recv_data, &recv_len);
+	static enum calibration_shell_state cal_state = CAL_START;
-		if (uart_recv_status >= 1) {
+	shellmatta_retCode_t ret_val = SHELLMATTA_BUSY;
-			for (iter = 0; iter < recv_len; iter++) {
+	uint32_t i;
-				if (recv_data[iter] == '\n' || recv_data[iter] == '\r')
+	int res;
-					enter_received = 1;
+
+	static float mu = 0.0f, mu2 = 0.0f, dev = 0.0f, dev2 = 0.0f;
+	float sens_dev, offset;
+	static float *data_buffer = NULL;
+	static volatile int flag;
+	char *stdin_data;
+	uint32_t stdin_len;
+
+
+	switch (cal_state) {
+	case CAL_START:
+		/* Clear errors of PT1000 reading */
+		adc_pt1000_clear_error();
+		shellmatta_printf(shell, "Starting calibration: Insert 1000 Ohm calibration resistor and press ENTER\r\n");
+		cal_state = CAL_WAIT_RES1;
+		ret_val = SHELLMATTA_CONTINUE;
+		break;
+	case CAL_WAIT_RES1:
+		cal_state = CAL_WAIT_RES1;
+		ret_val = SHELLMATTA_CONTINUE;
+		shellmatta_read(shell, &stdin_data, &stdin_len);
+		if (stdin_len > 0) {
+			for (i = 0; i < stdin_len; i++) {
+				if (stdin_data[i] == '\r') {
+					cal_state = CAL_MEAS_RES1;
+					ret_val = SHELLMATTA_BUSY;
+					shellmatta_printf(shell, "Measurement...\r\n");
+					adc_pt1000_clear_error();
+					data_buffer = calibration_acquire_data_start(512UL, &flag);
+					break;
+				} else if (stdin_data[i] == '\x03') {
+					cal_state = CAL_START;
+				}
 			}
 		}
-	} while (enter_received == 0);
+
-}
+		break;
-
+	case CAL_MEAS_RES1:
-int calibration_sequence_shell_cmd(shellmatta_handle_t shell)
+		if (!data_buffer) {
-{
+			shellmatta_printf(shell, "Data acquisition failed!\r\n");
-	float mu, mu2, dev, dev2;
+			ret_val = SHELLMATTA_OK;
-	float sens_dev, offset;
+			cal_state = CAL_START;
-
+			break;
-	/* Clear errors of PT1000 reading */
+		}
-	adc_pt1000_clear_error();
+
-
+		res = calibration_poll_data_acquisition(data_buffer, 512UL, &flag, &mu, &dev);
-	shellmatta_printf(shell, "Starting calibration: Insert 1000 Ohm calibration resistor and press ENTER\r\n");
+		/* Stay in this state until the measurements are finished */
-	wait_for_uart_enter();
+		if (res == 1) {
-	shellmatta_printf(shell, "Measurement...\r\n");
+			ret_val = SHELLMATTA_BUSY;
-
+			cal_state = CAL_MEAS_RES1;
-	/* Clear errors of PT1000 reading */
+		} else if (res == 0) {
-	adc_pt1000_clear_error();
+			shellmatta_printf(shell, "R=%.2f, Noise peak-peak: %.2f\r\n", mu, dev);
-	calibration_acquire_data(&mu, &dev, 512UL);
+			if (adc_pt1000_check_error() != ADC_PT1000_NO_ERR) {
-	shellmatta_printf(shell, "R=%.2f, Noise peak-peak: %.2f\r\n", mu, dev);
+				shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
-	if (adc_pt1000_check_error() != ADC_PT1000_NO_ERR) {
+				ret_val = SHELLMATTA_OK;
-		shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
+				cal_state = CAL_START;
-		return -1;
+			} else {
-	}
+				ret_val = SHELLMATTA_CONTINUE;
-
+				shellmatta_printf(shell, "Insert 2000 Ohm calibration resistor and press ENTER\r\n");
-	/* Measure 2nd calibration point */
+				cal_state = CAL_WAIT_RES2;
-	shellmatta_printf(shell, "Insert 2000 Ohm calibration resistor and press ENTER\r\n");
+			}
-	wait_for_uart_enter();
+		} else {
-	shellmatta_printf(shell, "Measurement...\r\n");
+			shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
-
+			ret_val = SHELLMATTA_OK;
-	/* Clear errors of PT1000 reading */
+			cal_state = CAL_START;
-	adc_pt1000_clear_error();
+		}
-	calibration_acquire_data(&mu2, &dev2, 512UL);
+		break;
-	shellmatta_printf(shell, "R=%.2f, Noise peak-peak: %.2f\r\n", mu2, dev2);
+	case CAL_WAIT_RES2:
-	if (adc_pt1000_check_error() != ADC_PT1000_NO_ERR) {
+		cal_state = CAL_WAIT_RES2;
-		shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
+		ret_val = SHELLMATTA_CONTINUE;
-		return -2;
+		shellmatta_read(shell, &stdin_data, &stdin_len);
-	}
+		if (stdin_len > 0) {
-
+			for (i = 0; i < stdin_len; i++) {
-	/* Check noise values */
+				if (stdin_data[i] == '\r') {
-	if (dev > CALIBRATION_MAX_PEAK_PEAK_NOISE_OHM || dev2 > CALIBRATION_MAX_PEAK_PEAK_NOISE_OHM) {
+					cal_state = CAL_MEAS_RES2;
-		shellmatta_printf(shell, "Calibration failed! Too much noise. Check you're hardware.\r\n");
+					ret_val = SHELLMATTA_BUSY;
-		return -3;
+					shellmatta_printf(shell, "Measurement...\r\n");
-	}
+					adc_pt1000_clear_error();
-
+					data_buffer = calibration_acquire_data_start(512UL, &flag);
-	/* Calculate calibration */
+					break;
-	calibration_calculate(mu, 1000.0f, mu2, 2000.0f, &sens_dev, &offset);
+				} else if (stdin_data[i] == '\x03') {
-
+					cal_state = CAL_START;
-	shellmatta_printf(shell, "Calibration done:\r\n\tSENS_DEVIATION: %.4f\r\n\tOFFSET_CORR: %.2f\r\n", sens_dev, offset);
+				}
-	adc_pt1000_set_resistance_calibration(offset, sens_dev, true);
+			}
-
+		}
-	return 0;
+
+		break;
+	case CAL_MEAS_RES2:
+		if (!data_buffer) {
+			shellmatta_printf(shell, "Data acquisition failed!\r\n");
+			ret_val = SHELLMATTA_OK;
+			cal_state = CAL_START;
+			break;
+		}
+
+		res = calibration_poll_data_acquisition(data_buffer, 512UL, &flag, &mu2, &dev2);
+		/* Stay in this state until the measurements are finished */
+		if (res == 1) {
+			ret_val = SHELLMATTA_BUSY;
+			cal_state = CAL_MEAS_RES2;
+		} else if (res == 0) {
+			shellmatta_printf(shell, "R=%.2f, Noise peak-peak: %.2f\r\n", mu2, dev2);
+			if (adc_pt1000_check_error() != ADC_PT1000_NO_ERR) {
+				shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
+				ret_val = SHELLMATTA_OK;
+				cal_state = CAL_START;
+			} else {
+				ret_val = SHELLMATTA_OK;
+				cal_state = CAL_START;
+
+				if (dev > CALIBRATION_MAX_PEAK_PEAK_NOISE_OHM ||
+				    dev2 > CALIBRATION_MAX_PEAK_PEAK_NOISE_OHM) {
+					shellmatta_printf(shell, "Calibration failed! Too much noise. Check your hardware.\r\n");
+					break;
+				}
+				shellmatta_printf(shell, "Calibartion finished successfully!\r\n");
+				/* Calculate calibration */
+				calibration_calculate(mu, 1000.0f, mu2, 2000.0f, &sens_dev, &offset);
+
+				shellmatta_printf(shell, "\r\n\tSENS_DEVIATION: %.4f\r\n\tOFFSET_CORR: %.2f\r\n", sens_dev, offset);
+				adc_pt1000_set_resistance_calibration(offset, sens_dev, true);
+			}
+		} else {
+			shellmatta_printf(shell, "Error in resistance measurement: %d", adc_pt1000_check_error());
+			ret_val = SHELLMATTA_OK;
+			cal_state = CAL_START;
+		}
+		break;
+	default:
+		shellmatta_printf(shell, "Undefined state reached in calibration. Aborting\r\n");
+		cal_state = CAL_START;
+		ret_val = SHELLMATTA_OK;
+		break;
+	}
+
+	return ret_val;
 }

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

@@ -2,6 +2,7 @@
 
 import os
 import sys
+import pathlib
 
 license_header = """/* Reflow Oven Controller
 *
@@ -13,7 +14,7 @@ license_header = """/* Reflow Oven Controller
 * 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,
+* 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.
@@ -22,7 +23,6 @@ license_header = """/* Reflow Oven Controller
 * along with the reflow oven controller project.
 * If not, see <http://www.gnu.org/licenses/>.
 */
-
 """
 
 project_dir = os.path.dirname(os.path.realpath(__file__))
@@ -37,19 +37,23 @@ 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('-', '_').upper()+'__'
+h_define = '__'+hfile.replace('.', '_').replace('-', '_').replace('/', '_').upper()+'__'
 
 if os.path.exists(cpath) or os.path.exists(hpath):
 	print("File already exists! Abort!")
 	sys.exit()
 
 print('Creating C file: %s' % (cpath))
+cfile_folder = os.path.dirname(cpath)
+pathlib.Path(cfile_folder).mkdir(parents=True, exist_ok=True)
 with open(cpath, 'x') as f:
 	f.write(license_header)
 	f.write('\n')
 	f.write('#include <%s>' % (os.path.join(include_prefix, hfile)))
 
 print('Creating H file: %s' % (hpath))
+hfile_folder = os.path.dirname(hpath)
+pathlib.Path(hfile_folder).mkdir(parents=True, exist_ok=True)
 with open(hpath, 'x') as f:
 	f.write(license_header)
 	f.write('\n')

stm-firmware/create-temp-lookup-table.py

@@ -14,7 +14,7 @@ license_header = """/* Reflow Oven Controller
 * 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,
+* 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.

stm-firmware/digio.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -27,6 +27,7 @@
 static const uint8_t digio_pins[] = {DIGIO_PINS};
 static const uint8_t digio_default_io[] = {DIGIO_INOUT_DEFAULT};
 static const uint8_t digio_default_altfunc[] = {DIGIO_ALTFUNC_DEFAULT};
+static uint16_t loudspeaker_val;
 
 static void digio_setup_pin_int(uint8_t bit_no, uint8_t in_out, uint8_t alt_func)
 {
@@ -118,6 +119,19 @@ int led_get(uint8_t num)
 	return ((LED_PORT->ODR & (1<<led_pins[num])) ? 1 : 0);
 }
 
+
+static void loudspeaker_freq_timer_init(void)
+{
+#if LOUDSPEAKER_MULTIFREQ
+	rcc_manager_enable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(RCC_APB1ENR_TIM7EN));
+	TIM7->CR1 = 0UL;
+	TIM7->CR2 = 0UL;
+	TIM7->PSC = 1000;
+	TIM7->DIER = TIM_DIER_UIE;
+	NVIC_EnableIRQ(TIM7_IRQn);
+#endif
+}
+
 void loudspeaker_setup()
 {
 	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(LOUDSPEAKER_RCC_MASK));
@@ -125,16 +139,56 @@ void loudspeaker_setup()
 	LOUDSPEAKER_PORT->MODER &= MODER_DELETE(LOUDSPEAKER_PIN);
 	LOUDSPEAKER_PORT->MODER |= OUTPUT(LOUDSPEAKER_PIN);
 
-	loudspeaker_set(0);
+	loudspeaker_freq_timer_init();
+	loudspeaker_set(0U);
 }
-void loudspeaker_set(int val)
+
+static void loudspeaker_start_beep(uint16_t val)
 {
-	if (val)
+#if LOUDSPEAKER_MULTIFREQ
-		LOUDSPEAKER_PORT->ODR |= (1<<LOUDSPEAKER_PIN);
+	TIM7->ARR = val;
-	else
+	TIM7->CNT = 0UL;
-		LOUDSPEAKER_PORT->ODR &= ~(1<<LOUDSPEAKER_PIN);
+	TIM7->CR1 |= TIM_CR1_CEN;
+#else
+	(void)val;
+	LOUDSPEAKER_PORT->ODR |= (1<<LOUDSPEAKER_PIN);
+#endif
 }
-int loudspeaker_get()
+
+static void loudspeaker_stop_beep(void)
 {
-	return ((LOUDSPEAKER_PORT->ODR & (1<<LOUDSPEAKER_PIN)) ? 1 : 0);
+#if LOUDSPEAKER_MULTIFREQ
+	TIM7->CR1 &= ~TIM_CR1_CEN;
+	__DSB();
+	TIM7->SR = 0UL;
+	__DSB();
+	LOUDSPEAKER_PORT->ODR &= ~(1<<LOUDSPEAKER_PIN);
+#else
+	LOUDSPEAKER_PORT->ODR &= ~(1<<LOUDSPEAKER_PIN);
+#endif
 }
+
+void loudspeaker_set(uint16_t val)
+{
+	loudspeaker_val = val;
+
+	if (!val) {
+		loudspeaker_stop_beep();
+	} else {
+		loudspeaker_start_beep(val);
+	}
+}
+
+uint16_t loudspeaker_get()
+{
+	return loudspeaker_val;
+}
+
+#if LOUDSPEAKER_MULTIFREQ
+void TIM7_IRQHandler(void)
+{
+	TIM7->SR = 0UL;
+	__DSB();
+	LOUDSPEAKER_PORT->ODR ^= (1<<LOUDSPEAKER_PIN);
+}
+#endif

stm-firmware/fatfs/diskio.c

@@ -0,0 +1,119 @@
+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2019        */
+/*-----------------------------------------------------------------------*/
+/* If a working storage control module is available, it should be        */
+/* attached to the FatFs via a glue function rather than modifying it.   */
+/* This is an example of glue functions to attach various exsisting      */
+/* storage control modules to the FatFs module with a defined API.       */
+/*-----------------------------------------------------------------------*/
+
+#include <fatfs/ff.h>			/* Obtains integer types */
+#include <fatfs/diskio.h>		/* Declarations of disk functions */
+#include "shimatta_sdio_driver/shimatta_sdio.h"
+
+/* Definitions of physical drive number for each drive */
+#define DEV_SD		0	/* Example: Map MMC/SD card to physical drive 0*/
+/*
+DSTATUS SDIO_status();
+DSTATUS SDIO_initialize();
+DRESULT SDIO_disk_read(BYTE *buff, DWORD sector, UINT count);
+DRESULT SDIO_disk_write(const BYTE *buff, DWORD sector, UINT count);
+DRESULT SDIO_disk_ioctl(BYTE cmd, void* buff);
+*/
+/*-----------------------------------------------------------------------*/
+/* Get Drive Status                                                      */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status (
+	BYTE pdrv		/* Physical drive nmuber to identify the drive */
+)
+{
+
+	switch (pdrv) {
+	case DEV_SD:
+		return sdio_status();
+	}
+	return STA_NOINIT;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize (
+	BYTE pdrv				/* Physical drive nmuber to identify the drive */
+)
+{
+	switch (pdrv) {
+	case DEV_SD:
+		return sdio_initialize();
+	}
+	return STA_NOINIT;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_read (
+	BYTE pdrv,		/* Physical drive nmuber to identify the drive */
+	BYTE *buff,		/* Data buffer to store read data */
+	LBA_t sector,	/* Start sector in LBA */
+	UINT count		/* Number of sectors to read */
+)
+{
+	switch (pdrv) {
+	case DEV_SD:
+		return sdio_disk_read(buff, sector, count);
+	}
+	return RES_PARERR;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+/*-----------------------------------------------------------------------*/
+
+#if FF_FS_READONLY == 0
+
+DRESULT disk_write (
+	BYTE pdrv,			/* Physical drive nmuber to identify the drive */
+	const BYTE *buff,	/* Data to be written */
+	LBA_t sector,		/* Start sector in LBA */
+	UINT count			/* Number of sectors to write */
+)
+{
+	switch (pdrv) {
+	case DEV_SD:
+		return sdio_disk_write(buff, sector, count);
+	}
+
+	return RES_PARERR;
+}
+
+#endif
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_ioctl (
+	BYTE pdrv,		/* Physical drive nmuber (0..) */
+	BYTE cmd,		/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+)
+{
+	switch (pdrv) {
+	case DEV_SD:
+		return sdio_disk_ioctl(cmd, buff);
+	}
+
+	return RES_PARERR;
+}
+

stm-firmware/fatfs/ffsystem.c

@@ -0,0 +1,170 @@
+/*------------------------------------------------------------------------*/
+/* Sample Code of OS Dependent Functions for FatFs                        */
+/* (C)ChaN, 2018                                                          */
+/*------------------------------------------------------------------------*/
+
+
+#include <fatfs/ff.h>
+
+
+#if FF_USE_LFN == 3	/* Dynamic memory allocation */
+
+/*------------------------------------------------------------------------*/
+/* Allocate a memory block                                                */
+/*------------------------------------------------------------------------*/
+
+void* ff_memalloc (	/* Returns pointer to the allocated memory block (null if not enough core) */
+	UINT msize		/* Number of bytes to allocate */
+)
+{
+	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 (nothing to do if null) */
+)
+{
+	free(mblock);	/* Free the memory block with POSIX API */
+}
+
+#endif
+
+
+
+#if FF_FS_REENTRANT	/* Mutal exclusion */
+
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* 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.
+*/
+
+//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 */
+)
+{
+	/* Win32 */
+	*sobj = CreateMutex(NULL, FALSE, NULL);
+	return (int)(*sobj != INVALID_HANDLE_VALUE);
+
+	/* uITRON */
+//	T_CSEM csem = {TA_TPRI,1,1};
+//	*sobj = acre_sem(&csem);
+//	return (int)(*sobj > 0);
+
+	/* uC/OS-II */
+//	OS_ERR err;
+//	*sobj = OSMutexCreate(0, &err);
+//	return (int)(err == OS_NO_ERR);
+
+	/* FreeRTOS */
+//	*sobj = xSemaphoreCreateMutex();
+//	return (int)(*sobj != NULL);
+
+	/* CMSIS-RTOS */
+//	*sobj = osMutexCreate(&Mutex[vol]);
+//	return (int)(*sobj != NULL);
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* 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.
+*/
+
+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 */
+)
+{
+	/* Win32 */
+	return (int)CloseHandle(sobj);
+
+	/* uITRON */
+//	return (int)(del_sem(sobj) == E_OK);
+
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);
+//	return (int)(err == OS_NO_ERR);
+
+	/* FreeRTOS */
+//  vSemaphoreDelete(sobj);
+//	return 1;
+
+	/* CMSIS-RTOS */
+//	return (int)(osMutexDelete(sobj) == osOK);
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access 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_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
+	FF_SYNC_t sobj	/* Sync object to wait */
+)
+{
+	/* Win32 */
+	return (int)(WaitForSingleObject(sobj, FF_FS_TIMEOUT) == WAIT_OBJECT_0);
+
+	/* uITRON */
+//	return (int)(wai_sem(sobj) == E_OK);
+
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexPend(sobj, FF_FS_TIMEOUT, &err));
+//	return (int)(err == OS_NO_ERR);
+
+	/* FreeRTOS */
+//	return (int)(xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);
+
+	/* CMSIS-RTOS */
+//	return (int)(osMutexWait(sobj, FF_FS_TIMEOUT) == osOK);
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on leaving file functions to unlock the volume.
+*/
+
+void ff_rel_grant (
+	FF_SYNC_t sobj	/* Sync object to be signaled */
+)
+{
+	/* Win32 */
+	ReleaseMutex(sobj);
+
+	/* uITRON */
+//	sig_sem(sobj);
+
+	/* uC/OS-II */
+//	OSMutexPost(sobj);
+
+	/* FreeRTOS */
+//	xSemaphoreGive(sobj);
+
+	/* CMSIS-RTOS */
+//	osMutexRelease(sobj);
+}
+
+#endif
+

stm-firmware/fatfs/shimatta_sdio_driver/shimatta_sdio.c

@@ -0,0 +1,740 @@
+#include "shimatta_sdio.h"
+#include "shimatta_sdio_config.h"
+#include <cmsis/core_cm4.h>
+#include <stm32/stm32f4xx.h>
+
+extern void sdio_wait_ms(unsigned int i);
+
+#define SETAF(PORT,PIN,AF)  PORT->AFR[(PIN < 8 ? 0 : 1)] |= AF << ((PIN < 8 ? PIN : (PIN - 8)) * 4)
+
+#define READCTRL ((BLOCKSIZE << 4) | SDIO_DCTRL_DMAEN)
+#define DMAP2M (DMA_SxCR_CHSEL_2 | DMA_SxCR_PBURST_0 | DMA_SxCR_MBURST_0 | DMA_SxCR_MSIZE_1 | DMA_SxCR_PSIZE_1 | DMA_SxCR_MINC | DMA_SxCR_PFCTRL)
+#define DMAM2P (DMA_SxCR_CHSEL_2 | DMA_SxCR_PBURST_0 | DMA_SxCR_MBURST_0 | DMA_SxCR_MSIZE_1 | DMA_SxCR_PSIZE_1 | DMA_SxCR_MINC | DMA_SxCR_PFCTRL | DMA_SxCR_DIR_0)
+#define SHORT_ANS 1
+#define LONG_ANS 3
+#define NO_ANS 0
+
+#define CCRCFAIL 1
+#define CTIMEOUT 2
+#define CNOTEXPETED 3
+
+/* OCR Register Masks */
+#define OCS_CCS (1<<30)
+#define OCS_BUSY (1<<31)
+
+enum acmd41_ret {ACMD41_RESP_INIT = 0, ACMD41_RESP_ERR, ACMD41_RESP_SDSC, ACMD41_RESP_SDXC};
+enum cmd8_ret {CMD8_RESP_TIMEOUT = 0, CMD8_VOLTAGE_ACCEPTED, CMD8_VOLTAGE_DENIED};
+typedef uint8_t CID_t;
+
+static struct sd_info card_info; // = {.type = CARD_NONE};
+
+/**
+ * @brief checkNotInserted
+ * @return return 0 if card is inserted, else 1
+ */
+int sdio_check_inserted() {
+#if SDIO_ENABLE_INS
+	return ((INS_PORT->IDR & (1<<INS_PIN)) == (INS_ACTIVE_LEVEL<<INS_PIN) ? 0 : 1);
+#else
+	return 0; // Assume Card is inserted
+#endif
+}
+
+/**
+ * @brief checkWriteProtection
+ * @return 0 if card is writable.
+ */
+static int sdio_check_write_protection() {
+#if SDIO_ENABLE_WRITEPROT
+	return ((WRITEPROT_PORT->IDR & (1<<WRITEPROT_PIN)) == (WRITEPROT_ACTIVE_LEVEL<<WRITEPROT_PIN) ? 1 : 0);
+#else
+	return 0; // Assume Card is not write protected
+#endif
+}
+
+static void sdio_wait_cmd_sent()
+{
+	while (!(SDIO->STA & SDIO_STA_CMDSENT));
+	SDIO->ICR |= SDIO_ICR_CMDSENTC;
+}
+
+static int sdio_send_cmd(uint8_t cmd, uint32_t arg, uint8_t expected_ans){
+	/* Clear Flags */
+	SDIO->ICR = SDIO_ICR_CCRCFAILC | SDIO_ICR_CMDRENDC | SDIO_ICR_CTIMEOUTC | SDIO_ICR_CMDSENTC;
+	/* Send command */
+	SDIO->ARG = arg;
+	SDIO->CMD = (cmd & SDIO_CMD_CMDINDEX) | SDIO_CMD_CPSMEN | ((expected_ans << 6) & SDIO_CMD_WAITRESP);
+	return 0;
+}
+
+static int sdio_get_response(uint8_t expected_command, uint8_t type_of_answer, uint32_t *response_buffer) {
+	uint32_t sdio_status;
+
+	/* Wait until command isn't active anymore */
+	while (SDIO->STA & SDIO_STA_CMDACT);
+
+	/* Wait for error or success */
+	while (1) {
+		sdio_status = SDIO->STA;
+
+		/* Check if a valid response was received */
+		if (sdio_status & SDIO_STA_CMDREND)
+			break;
+
+		if ((sdio_status & SDIO_STA_CMDSENT) && (type_of_answer == NO_ANS))
+			break; // No response required
+
+		/* Exclude ACMD41 and CMD2 from valid CRC check */
+		if ((sdio_status & SDIO_STA_CCRCFAIL)) {
+			if(expected_command == 0xff) {
+				break;
+			} else {
+				return -CCRCFAIL;
+			}
+		}
+
+		if (sdio_status & SDIO_STA_CTIMEOUT)
+			return -CTIMEOUT;
+	}
+
+	/* Valid Respone Received */
+	if (((SDIO->RESPCMD & SDIO_RESPCMD_RESPCMD) != expected_command) && (expected_command != 0xff))
+		return -CNOTEXPETED; //Not the expected respose
+
+	/* If case of a correct Response */
+	*(response_buffer++) = SDIO->RESP1;
+
+	/* Long response */
+	if (type_of_answer == LONG_ANS) {
+		*(response_buffer++) = SDIO->RESP2;
+		*(response_buffer++) = SDIO->RESP3;
+		*(response_buffer++) = SDIO->RESP4;
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Switch the card to application mode. It now accepts ACMDXX commands
+ * @return 0 if successfuls
+ */
+static int sdio_switch_appmode_cmd55()
+{
+	int retry = 0x20;
+	union sdio_status_conv converter;
+	uint32_t response;
+	do {
+		/* Execute Command and check for valid response */
+		sdio_send_cmd(55, (card_info.rca<<16)&0xFFFF0000, SHORT_ANS);
+
+		if (!sdio_get_response(55, SHORT_ANS, &response))
+		{
+			/* Response valid. Check if Card has accepted switch to application command mode */
+			converter.value = response;
+			if (converter.statusstruct.APP_CMD == 1)
+				return 0;
+		}
+	} while (--retry > 0);
+
+	return -1;
+}
+
+enum acmd41_ret sdio_init_card_acmd41(uint8_t HCS){
+	uint32_t response;
+	int retry = 0x20;
+	if (sdio_switch_appmode_cmd55())
+		return ACMD41_RESP_ERR;
+
+	do {
+		sdio_send_cmd(41, (HCS ? (1<<30) : 0) | (1<<28) | (1<<20) |(1<<21)|(1<<22) |(1<<23)|(1<<19), SHORT_ANS);
+		if (!sdio_get_response(0xFF, SHORT_ANS, &response)) {
+			if (response & OCS_BUSY) {
+				/* Card is ready... Who knows why this bit is called busy */
+				if (response & OCS_CCS) {
+					return ACMD41_RESP_SDXC;
+				} else {
+					return ACMD41_RESP_SDSC;
+				}
+			} else {
+				return ACMD41_RESP_INIT;
+			}
+		}
+	} while (--retry > 0);
+
+	return ACMD41_RESP_ERR;
+}
+
+static int sdio_send_csd_cmd9(uint16_t rca, uint32_t *response_buffer) {
+	int timeout = 0x20;
+	int res;
+
+	do {
+		sdio_send_cmd(9, (rca<<16)&0xFFFF0000, LONG_ANS);
+		res = sdio_get_response(0xFF, LONG_ANS, response_buffer);
+		if (!res)
+			break;
+	} while (--timeout > 0);
+
+	return res;
+}
+
+/**
+ * @brief Send data buffer to SD card
+ * @param dlen Data length. Must be a multiple of 4 bytes
+ * @param blklen Log2 of block length (9 in case of 512 byte block)
+ * @param buff Buffer to send
+ */
+static void sdio_write_buffer(uint32_t dlen, uint32_t log_blklen, const unsigned char *buff)
+{
+	uint32_t count;
+	int byte_count;
+	int byte_max;
+	uint32_t fifo;
+
+	SDIO->DLEN = dlen;
+
+	/* Init Transfer */
+	SDIO->ICR = SDIO_ICR_CCRCFAILC | SDIO_ICR_DCRCFAILC | SDIO_ICR_CTIMEOUTC | SDIO_ICR_DTIMEOUTC |
+			SDIO_ICR_TXUNDERRC | SDIO_ICR_RXOVERRC | SDIO_ICR_CMDRENDC | SDIO_ICR_CMDSENTC | SDIO_ICR_DATAENDC |
+			SDIO_ICR_STBITERRC | SDIO_ICR_DBCKENDC | SDIO_ICR_SDIOITC | SDIO_ICR_CEATAENDC;
+	SDIO->DCTRL = (log_blklen<<4) | SDIO_DCTRL_DTEN;
+
+	for (count = 0; count < dlen; count += 4) {
+		fifo = 0;
+
+		if ((dlen - count) < 4)
+			byte_max = dlen - count;
+		else
+			byte_max = 4;
+
+		for (byte_count = 0; byte_count < byte_max; byte_count++) {
+			fifo >>= 8;
+			fifo |= (((uint32_t)*(buff++)) << 24) & 0xFF000000;
+		}
+
+		/* Wait as long as FIFO is full */
+		while (SDIO->STA & SDIO_STA_TXFIFOF);
+
+		/* Write data to FIFO */
+		SDIO->FIFO = fifo;
+	}
+
+	/* Wait for TX to complete */
+	while (SDIO->STA & SDIO_STA_TXACT);
+}
+
+static int sdio_send_write_block_cmd24(uint32_t addr)
+{
+	uint32_t response;
+
+	sdio_send_cmd(24, addr, SHORT_ANS);
+
+	return sdio_get_response(24, SHORT_ANS, &response);
+}
+
+static int sdio_check_status_register_cmd13(uint16_t rca, uint32_t *status)
+{
+	int timeout = 0x20;
+	uint32_t response;
+	int res;
+
+	*status = 0UL;
+
+	do {
+		sdio_send_cmd(13, (rca<<16)&0xFFFF0000, SHORT_ANS);
+		if (!(res = sdio_get_response(13, SHORT_ANS, &response))) {
+			*status = response;
+			break;
+		}
+	} while (--timeout > 0);
+
+	return res;
+}
+
+static int sdio_send_bus_width_acmd6(uint8_t bus_width)
+{
+	uint32_t response;
+	int retry = 0x20;
+	int ret;
+
+	if (sdio_switch_appmode_cmd55()) return -1;
+	do {
+		sdio_send_cmd(0x6, (bus_width == 4 ? 0x2 : 0x0), SHORT_ANS);
+		ret = sdio_get_response(0x6, SHORT_ANS, &response);
+		if (!ret)
+			return 0;
+
+	} while (--retry > 0);
+
+	return ret;
+
+}
+
+static int sdio_get_sector_count(uint16_t rca, uint32_t *sector_count)
+{
+	uint32_t csd[4];
+	int res;
+	uint32_t size, mult, read_len, csd_rev;
+
+	if ((res = sdio_send_csd_cmd9(rca, csd))) {
+		return -1;
+	}
+
+	csd_rev = ((csd[0] >> 30) & (0x3));
+
+	if (csd_rev == 0) {
+		/* SD v1 Card */
+		size = ((csd[1] & 0x3FF) <<2) | (((csd[2]) & ((1<<31) | (1<<30)))>>30);
+		mult = ((csd[2] & ((1<<17)|(1<<16)|(1<<15)))>>15);
+		read_len = (1<<((csd[1] & ((1<<19)|(1<<18)|(1<<17)|(1<<16)))>>16));
+		*sector_count = (((size +1)*(1<<(mult+2))*read_len) >> BLOCKSIZE);
+	} else if (csd_rev == 1) {
+		/* SD v2 Card */
+		size = (((csd[1] & 0x3F)<<16) | ((csd[2] & 0xFFFF0000) >> 16));
+		*sector_count = (size << (19-BLOCKSIZE));
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Switch the SDIo prescaler
+ * @param Prescaler value
+ */
+static void sdio_switch_prescaler(uint8_t clkdiv)
+{
+	uint32_t reg;
+	reg = SDIO->CLKCR;
+	/* Clear prescaler */
+	reg &= ~SDIO_CLKCR_CLKDIV;
+	/* Set bits */
+	reg |= (SDIO_CLKCR_CLKDIV & clkdiv);
+	SDIO->CLKCR = reg;
+}
+
+/**
+ * @brief initDetectandProtectionPins
+ */
+static void sdio_init_detect_pins()
+{
+#if SDIO_ENABLE_WRITEPROT==1
+	WRITEPROT_PORT->PUPDR |= ((WRITEPROT_PULLUP ? 1 : 0)<<WRITEPROT_PIN*2);
+#endif /* SDIO_ENABLE_WRITEPROT */
+#if SDIO_ENABLE_INS==1
+	INS_PORT->PUPDR |= ((INS_PULLUP? 1 : 0)<<INS_PIN*2);
+#endif /* SDIO_ENABLE_INS */
+	__DSB();
+}
+
+static void sdio_init_hw()
+{
+	//Init Clocks
+	RCC->AHB1ENR    |= PORTCLKMASK | RCC_AHB1ENR_DMA2EN;
+	RCC->APB2ENR    |= RCC_APB2ENR_SDIOEN;
+	//Init Alternate Functions
+	CLKPORT->MODER  |= (2<<CLKPIN*2);
+	D0PORT->MODER   |= (2<<D0PIN*2);
+	D0PORT->PUPDR   |= (1<<D0PIN*2);
+	CMDPORT->MODER  |= (2<<CMDPIN*2);
+	CMDPORT->PUPDR	|= (1<<CMDPIN*2);
+#if BUSWIDTH==4
+	D1PORT->MODER   |= (2<<D1PIN*2);
+	D1PORT->PUPDR   |= (1<<D1PIN*2);
+	D2PORT->MODER   |= (2<<D2PIN*2);
+	D2PORT->PUPDR   |= (1<<D2PIN*2);
+	D3PORT->MODER   |= (2<<D3PIN*2);
+	D3PORT->PUPDR   |= (1<<D3PIN*2);
+#endif
+	//CLKPORT->AFR[(CLKPIN < 8 ? 0 : 1)] |= ALTFUNC << ((CLKPIN < 8 ? CLKPIN : (CLKPIN - 8)) * 4);
+	SETAF(CLKPORT,  CLKPIN, ALTFUNC);
+	SETAF(CMDPORT, CMDPIN, ALTFUNC);
+	SETAF(D0PORT,   D0PIN,  ALTFUNC);
+#if BUSWIDTH==4
+	SETAF(D1PORT, D1PIN,  ALTFUNC);
+	SETAF(D2PORT,   D2PIN,  ALTFUNC);
+	SETAF(D3PORT,   D3PIN,  ALTFUNC);
+#endif
+
+
+	//Init Module
+
+	//Set CLK Control Register
+	SDIO->CLKCR = (HW_FLOW<<14) | ((BUSWIDTH == 4 ? 1 : 0)<<11) | SDIO_CLKCR_CLKEN |
+			(INITCLK & SDIO_CLKCR_CLKDIV);
+
+	//Set Data Timeout
+	SDIO->DTIMER = DTIMEOUT;
+
+	//Set Data Parameters
+	//SDIO->DCTRL = (BLOCKSIZE << 4) | SDIO_DCTRL_DMAEN;
+	//Set Power Register: Power up Card CLK
+	SDIO->POWER = SDIO_POWER_PWRCTRL_0 | SDIO_POWER_PWRCTRL_1;
+
+}
+
+static int sdio_send_read_block_cmd17(uint32_t addr)
+{
+	uint32_t response;
+
+	sdio_send_cmd(17, addr, SHORT_ANS);
+	return sdio_get_response(17, SHORT_ANS, &response);
+}
+
+static int sdio_send_all_send_cid_cmd2()
+{
+	uint32_t response[4];
+	int ret;
+	int retry = 0x20;
+
+	do {
+		sdio_send_cmd(2, 0, LONG_ANS);
+		if (!(ret = sdio_get_response(0xFF, LONG_ANS, response)))
+			return 0;
+	} while (retry-- > 0);
+
+	return ret;
+}
+
+static int sdio_send_relative_address_cmd3(uint16_t* rca)
+{
+	uint32_t response;
+	int retry = 0x20;
+
+	do {
+		sdio_send_cmd(3, 0, SHORT_ANS);
+		if (!sdio_get_response(3, SHORT_ANS, &response)) {
+			// TODO: Do some *optional* checking
+			*rca = ((response & 0xFFFF0000) >> 16);
+			return 0;
+		}
+	} while (retry-- > 0);
+	return -1;
+}
+
+static int sdio_send_go_idle_cmd0() {
+	sdio_send_cmd(0, 0x0, NO_ANS);
+	sdio_wait_cmd_sent();
+	return 0;
+}
+
+static enum cmd8_ret sdio_send_iface_condition_cmd8()
+{
+	uint32_t response;
+	int res = 0;
+	int retry = 0x20;
+
+	do {
+		sdio_send_cmd(8, 0x1CC, SHORT_ANS); // 3.3V supply requesR
+		res = sdio_get_response(8, SHORT_ANS, &response);
+		if (res == 0) {
+			if (response & 0x100)
+				return CMD8_VOLTAGE_ACCEPTED;
+			else
+				return CMD8_VOLTAGE_DENIED;
+		}
+	} while (retry-- > 0);
+
+	return CMD8_RESP_TIMEOUT;
+}
+
+static int sdio_send_block_length_cmd16(uint32_t blocklen) {
+	int timeout = 0x20;
+	int res;
+	uint32_t response;
+
+	do {
+		sdio_send_cmd(16, blocklen, SHORT_ANS);
+		if (!(res = sdio_get_response(16, SHORT_ANS, &response))) {
+			return 0;
+		}
+	}while(--timeout > 0);
+
+	return res;
+}
+
+static int sdio_send_select_card_cmd7(uint16_t rca) {
+	int timeout = 0x20;
+	uint32_t response;
+	union sdio_status_conv status;
+	int res;
+
+	/* Send CMD7. Selects card */
+	do {
+		sdio_send_cmd(7, (rca<<16)&0xFFFF0000, SHORT_ANS);
+		if (!(res = sdio_get_response(7, SHORT_ANS, &response))) {
+			break;
+		}
+	} while(--timeout > 0);
+
+	/* Check, if card in in TRANS state */
+	if (sdio_check_status_register_cmd13(rca, &status.value)) {
+		res = -1;
+		goto ret_val;	
+	}
+	if (status.statusstruct.CURRENT_STATE != CURRENT_STATE_TRAN)
+		res = -2;
+
+ret_val:
+	return res;
+}
+
+DSTATUS sdio_status()
+{
+	DSTATUS returnval = 0;
+
+	if (sdio_check_inserted())
+		returnval |= STA_NODISK;
+
+	if (card_info.type == CARD_NONE)
+		returnval |= STA_NOINIT;
+
+	if (sdio_check_write_protection())
+		returnval |= STA_PROTECT;
+
+	return returnval;
+}
+
+DRESULT sdio_disk_ioctl(BYTE cmd, void* buff){
+	DRESULT res = RES_OK;
+
+	switch(cmd) {
+	case GET_BLOCK_SIZE:
+		*((DWORD*)buff) = (DWORD)0x01;
+		break;
+	case GET_SECTOR_SIZE:
+		*((WORD*)buff) = (WORD)(1<<BLOCKSIZE);
+		break;
+	case GET_SECTOR_COUNT:
+		if (card_info.type != CARD_NONE) {
+			*((DWORD*)buff) = (DWORD)card_info.sector_count;
+		} else {
+			res = RES_ERROR;
+		}
+		break;
+	case CTRL_SYNC:
+		res = RES_OK;
+		break;
+	default:
+		res = RES_PARERR;
+		break;
+	}
+
+	return res;
+}
+
+DWORD __attribute__((weak)) get_fattime()
+{
+	return (1<<16) | (1<<24); // return Jan. 1st 1980 00:00:00
+}
+
+DSTATUS sdio_initialize(){
+	int timeout = 0x3000;
+	enum cmd8_ret res8;
+	enum acmd41_ret resa41;
+	uint8_t hcs_flag = 0;
+	card_info.rca = 0;
+	card_info.type = CARD_NONE;
+	enum sdio_card_type detected_card = CARD_NONE;
+
+	sdio_init_hw();
+	sdio_wait_ms(2);
+	sdio_init_detect_pins();
+	if (sdio_check_inserted()) {
+		return STA_NOINIT | STA_NODISK;
+	}
+
+	sdio_send_go_idle_cmd0();
+
+	sdio_wait_ms(2);
+
+	res8 = sdio_send_iface_condition_cmd8();
+	switch (res8) {
+	case CMD8_VOLTAGE_ACCEPTED: // SDV2 Card
+		hcs_flag = 1;
+		break;
+	case CMD8_VOLTAGE_DENIED: // should not happen
+		return STA_NOINIT;
+		break;
+	case CMD8_RESP_TIMEOUT: // SDV1 Card
+		hcs_flag=0;
+		break;
+	default:
+		return STA_NOINIT;
+		break;
+	}
+
+	do {
+		//SDIO_wait_ms(2);
+		resa41 = sdio_init_card_acmd41(hcs_flag);
+	} while ((resa41 == ACMD41_RESP_INIT) && (--timeout > 0));
+
+	switch (resa41) {
+	case ACMD41_RESP_SDSC:
+		detected_card = (hcs_flag ? SD_V2_SC : SD_V1);
+		break;
+	case ACMD41_RESP_SDXC:
+		detected_card = SD_V2_HC;
+		break;
+	default:
+		return STA_NOINIT;
+		break;
+	}
+
+	if (sdio_send_all_send_cid_cmd2())
+		return STA_NOINIT;
+
+	if (sdio_send_relative_address_cmd3(&card_info.rca))
+		return STA_NOINIT;
+	if (sdio_get_sector_count(card_info.rca, &card_info.sector_count))
+		return STA_NOINIT;
+	if (sdio_send_select_card_cmd7(card_info.rca))
+		return STA_NOINIT;
+
+	if (sdio_send_block_length_cmd16((uint32_t)(1<<BLOCKSIZE)))
+		return STA_NOINIT;
+
+	if (sdio_send_bus_width_acmd6(BUSWIDTH))
+		return STA_NOINIT;
+
+	sdio_switch_prescaler(WORKCLK);
+
+	card_info.type = detected_card;
+
+	if (sdio_check_write_protection()) {
+		return STA_PROTECT;
+	} else
+		return 0;
+}
+
+DRESULT sdio_disk_read(BYTE *buff, DWORD sector, UINT count){
+	uint32_t addr;
+	uint32_t sdio_status;
+	uint32_t fifo;
+	uint32_t counter;
+
+	addr = (card_info.type == SD_V2_HC ? (sector) : (sector*512));
+	for (; count > 0; count--) {
+
+		/* configure read DMA */
+		//		DMA2->LIFCR = 0xffffffff;
+		//		DMA2->HIFCR = 0xffffffff;
+		//		DMASTREAM->NDTR = 0;
+		//		DMASTREAM->FCR = DMA_SxFCR_FTH_0 | DMA_SxFCR_FTH_1 | DMA_SxFCR_DMDIS;
+		//		DMASTREAM->M0AR = (uint32_t)(buff);
+		//		DMASTREAM->PAR = (uint32_t)&(SDIO->FIFO);
+		//		DMASTREAM->CR = DMAP2M | DMA_SxCR_PL_1 | DMA_SxCR_PL_1;
+		//		DMASTREAM->CR |= DMA_SxCR_EN;
+
+		SDIO->DLEN = (1 << BLOCKSIZE);
+
+		SDIO->ICR = SDIO_ICR_CCRCFAILC | SDIO_ICR_DCRCFAILC | SDIO_ICR_CTIMEOUTC | SDIO_ICR_DTIMEOUTC |
+				SDIO_ICR_TXUNDERRC | SDIO_ICR_RXOVERRC | SDIO_ICR_CMDRENDC | SDIO_ICR_CMDSENTC | SDIO_ICR_DATAENDC |
+				SDIO_ICR_STBITERRC | SDIO_ICR_DBCKENDC | SDIO_ICR_SDIOITC | SDIO_ICR_CEATAENDC;
+		SDIO->DCTRL = (BLOCKSIZE<<4) | SDIO_DCTRL_DTDIR | /*SDIO_DCTRL_DMAEN |*/ SDIO_DCTRL_DTEN;
+
+		/* Init Transfer */
+		if (sdio_send_read_block_cmd17(addr)) {
+			return RES_ERROR;
+		}
+
+		counter = 0;
+		while (counter < (1<<(BLOCKSIZE-2)) || !(SDIO->STA & (SDIO_STA_DBCKEND | SDIO_STA_DATAEND))) {
+			/* TODO: Handle errors */
+			if (SDIO->STA & (SDIO_STA_DCRCFAIL | SDIO_STA_DTIMEOUT | SDIO_STA_STBITERR))
+			{
+				return RES_ERROR;
+			}
+
+			if (SDIO->STA & SDIO_STA_RXDAVL) {
+				counter++;
+				fifo = SDIO->FIFO;
+				*(buff++) = (BYTE)(fifo & 0xFF);
+				fifo >>= 8;
+				*(buff++) = (BYTE)(fifo & 0xFF);
+				fifo >>= 8;
+				*(buff++) = (BYTE)(fifo & 0xFF);
+				fifo >>= 8;
+				*(buff++) = (BYTE)(fifo & 0xFF);
+			}
+
+		}
+		if (SDIO->STA & SDIO_STA_DCRCFAIL) return RES_ERROR;
+
+		//while(DMASTREAM->CR & DMA_SxCR_EN);
+		while(1) {
+			__DSB();
+			__DMB();
+			sdio_status = SDIO->STA;
+			if (sdio_status & SDIO_STA_DCRCFAIL) {
+				return RES_ERROR;
+			}
+			if (sdio_status & SDIO_STA_DTIMEOUT) {
+				return RES_ERROR;
+			}
+
+			if (sdio_status & SDIO_STA_DATAEND) {
+
+				if (!(sdio_status & SDIO_STA_RXACT)) {
+					break;
+				}
+			}
+		}
+
+		if (card_info.type == SD_V2_HC) {
+			addr++;
+		} else {
+			addr += (1<<BLOCKSIZE);
+		}
+	}
+	return RES_OK;
+}
+
+/**
+ * @brief SDIO_disk_write
+ * @param buff
+ * @param sector
+ * @param count
+ * @warning Not yet implemented
+ * @return
+ */
+DRESULT sdio_disk_write(const BYTE *buff, DWORD sector, UINT count)
+{
+	uint32_t addr;
+	union sdio_status_conv status;
+	uint32_t buff_offset = 0;
+	int ret;
+
+	if (sdio_check_write_protection())
+		return RES_WRPRT;
+
+	addr = (card_info.type == SD_V2_HC ? (sector) : (sector * 512));
+
+	while (count) {
+		do {
+			ret = sdio_check_status_register_cmd13(card_info.rca, &status.value);
+		} while (status.statusstruct.CURRENT_STATE == CURRENT_STATE_PRG ||
+			 status.statusstruct.CURRENT_STATE == CURRENT_STATE_RCV ||
+			 !ret);
+
+		if (status.statusstruct.CURRENT_STATE == CURRENT_STATE_STBY) {
+			if (sdio_send_select_card_cmd7(card_info.rca))
+				return RES_ERROR;
+		}
+
+		do {
+			sdio_check_status_register_cmd13(card_info.rca, &status.value);
+		} while (status.statusstruct.READY_FOR_DATA != 1);
+
+		ret = sdio_send_write_block_cmd24(addr);
+		if (ret) {
+			return RES_ERROR;
+		}
+		sdio_write_buffer(512, 9, &buff[buff_offset]);
+
+		buff_offset += 512;
+		addr += (card_info.type == SD_V2_HC ? 1 : 512);
+		count--;
+	}
+
+	return RES_OK;
+}

stm-firmware/fatfs/shimatta_sdio_driver/shimatta_sdio.h

@@ -0,0 +1,79 @@
+/*
+ * shimatta_sdio-driver.h
+ *
+ *  Created on: Apr 26, 2015
+ *  Mario Hüttel
+ */
+
+#ifndef FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_DRIVER_H_
+#define FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_DRIVER_H_
+
+#include <fatfs/diskio.h>
+#include <fatfs/ff.h>
+#include <stdint.h>
+
+DSTATUS sdio_status();
+DSTATUS sdio_initialize();
+
+DRESULT sdio_disk_read(BYTE *buff, DWORD sector, UINT count);
+DRESULT sdio_disk_write(const BYTE *buff, DWORD sector, UINT count);
+DRESULT sdio_disk_ioctl(BYTE cmd, void* buff);
+DWORD get_fattime();
+
+int sdio_check_inserted();
+
+
+//Defines for Card Status in struct _CardStatus
+#define CURRENT_STATE_IDLE 0
+#define CURRENT_STATE_READY 1
+#define CURRENT_STATE_IDENT 2
+#define CURRENT_STATE_STBY 3
+#define CURRENT_STATE_TRAN 4
+#define CURRENT_STATE_DATA 5
+#define CURRENT_STATE_RCV 6
+#define CURRENT_STATE_PRG 7
+#define CURRENT_STATE_DIS 8
+
+struct sd_card_status {
+    uint32_t reserved           : 3;
+    uint32_t AKE_SEQ_ERROR      : 1;
+    uint32_t reserved_2         : 1;
+    uint32_t APP_CMD            : 1;
+    uint32_t reserved_3         : 2;
+    uint32_t READY_FOR_DATA     : 1;
+    uint32_t CURRENT_STATE      : 4;
+    uint32_t ERASE_RESET        : 1;
+    uint32_t CARD_ECC_DIABLED   : 1;
+    uint32_t WP_ERASE_SKIP      : 1;
+    uint32_t CSD_OVERWRITE      : 1;
+    uint32_t reserved17         : 1;
+    uint32_t reserved18         : 1;
+    uint32_t ERROR              : 1;
+    uint32_t CC_ERROR           : 1;
+    uint32_t CARD_ECC_FAILED    : 1;
+    uint32_t ILLEGAL_COMMAND    : 1;
+    uint32_t COM_CRC_ERROR      : 1;
+    uint32_t LOCK_UNLOCK_FAILED : 1;
+    uint32_t CARD_IS_LOCKED     : 1;
+    uint32_t WP_VIOLATION       : 1;
+    uint32_t ERASE_PARAM        : 1;
+    uint32_t ERASE_SEQ_ERROR    : 1;
+    uint32_t BLOCK_LEN_ERROR    : 1;
+    uint32_t ADDRESS_ERROR      : 1;
+    uint32_t OUT_OF_RANGE       : 1;
+};
+
+enum sdio_card_type {CARD_NONE = 0, MMC, SD_V1, SD_V2_SC, SD_V2_HC};
+                        // MMC not supported
+struct sd_info {
+    uint16_t rca;
+    enum sdio_card_type type;
+    uint32_t sector_count;
+};
+
+union sdio_status_conv {
+    struct sd_card_status statusstruct;
+    uint32_t value;
+};
+
+#endif /* FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_DRIVER_H_ */

stm-firmware/fatfs/shimatta_sdio_driver/shimatta_sdio_config.h

@@ -0,0 +1,60 @@
+#ifndef FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_CONFIG_H_
+#define FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_CONFIG_H_
+
+#include <stm32/stm32f4xx.h>
+
+//General Definitions
+//Blocksize: 512 = 2^9 => 9
+#define BLOCKSIZE 9     //9
+//Hardware Flow: Prevents over- and underruns.
+#define HW_FLOW   0     //0
+//1 bit: !=4
+//4 bit: 4
+#define BUSWIDTH  4    //4
+//Initial Transfer CLK (ca. 400kHz)
+#define INITCLK   130   //120
+//Working CLK (Maximum)
+#define WORKCLK   50   //0
+//Data Timeout in CLK Cycles
+#define DTIMEOUT  0x3000   //150
+//DMA Stream used for TX and RX DMA2 Stream 3 or 6 possible
+// Currently not used due to possible misalignment of the data buffer.
+//#define DMASTREAM DMA2_Stream6
+
+
+/* Port Definitions */
+
+#define PORTCLKMASK (RCC_AHB1ENR_GPIODEN | RCC_AHB1ENR_GPIOCEN | RCC_AHB1ENR_GPIOAEN)
+
+#define ALTFUNC     12
+
+#define CLKPORT     GPIOC
+#define D0PORT      GPIOC
+#define D1PORT      GPIOC
+#define D2PORT      GPIOC
+#define D3PORT      GPIOC
+#define CMDPORT     GPIOD
+
+#define CLKPIN      12
+#define D0PIN       8
+#define D1PIN       9
+#define D2PIN       10
+#define D3PIN       11
+#define CMDPIN      2
+
+// Write Protection
+#define SDIO_ENABLE_WRITEPROT 0
+#define WRITEPROT_PORT GPIOD // Add this port to port clock mask!
+#define WRITEPROT_PIN 0
+#define WRITEPROT_PULLUP 0
+#define WRITEPROT_ACTIVE_LEVEL 0
+
+// Card inserted pin
+#define SDIO_ENABLE_INS 1
+#define INS_PORT GPIOA // Add this port to port clock mask!
+#define INS_PIN 8
+#define INS_PULLUP 1
+#define INS_ACTIVE_LEVEL 0
+
+
+#endif /* FATFS_SHIMATTA_SDIO_DRIVER_SHIMATTA_SDIO_CONFIG_H_ */

stm-firmware/include/fatfs/diskio.h

@@ -0,0 +1,79 @@
+/*-----------------------------------------------------------------------/
+/  Low level disk interface modlue include file   (C)ChaN, 2019          /
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <fatfs/ff.h>
+
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+	RES_OK = 0,		/* 0: Successful */
+	RES_ERROR,		/* 1: R/W Error */
+	RES_WRPRT,		/* 2: Write Protected */
+	RES_NOTRDY,		/* 3: Not Ready */
+	RES_PARERR		/* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+
+DSTATUS disk_initialize (BYTE pdrv);
+DSTATUS disk_status (BYTE pdrv);
+DRESULT disk_read (BYTE pdrv, BYTE* buff, LBA_t sector, UINT count);
+DRESULT disk_write (BYTE pdrv, const BYTE* buff, LBA_t sector, UINT count);
+DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT		0x01	/* Drive not initialized */
+#define STA_NODISK		0x02	/* No medium in the drive */
+#define STA_PROTECT		0x04	/* Write protected */
+
+
+/* Command code for disk_ioctrl fucntion */
+
+/* Generic command (Used by FatFs) */
+#define CTRL_SYNC			0	/* Complete pending write process (needed at FF_FS_READONLY == 0) */
+#define GET_SECTOR_COUNT	1	/* Get media size (needed at FF_USE_MKFS == 1) */
+#define GET_SECTOR_SIZE		2	/* Get sector size (needed at FF_MAX_SS != FF_MIN_SS) */
+#define GET_BLOCK_SIZE		3	/* Get erase block size (needed at FF_USE_MKFS == 1) */
+#define CTRL_TRIM			4	/* Inform device that the data on the block of sectors is no longer used (needed at FF_USE_TRIM == 1) */
+
+/* Generic command (Not used by FatFs) */
+#define CTRL_POWER			5	/* Get/Set power status */
+#define CTRL_LOCK			6	/* Lock/Unlock media removal */
+#define CTRL_EJECT			7	/* Eject media */
+#define CTRL_FORMAT			8	/* Create physical format on the media */
+
+/* MMC/SDC specific ioctl command */
+#define MMC_GET_TYPE		10	/* Get card type */
+#define MMC_GET_CSD			11	/* Get CSD */
+#define MMC_GET_CID			12	/* Get CID */
+#define MMC_GET_OCR			13	/* Get OCR */
+#define MMC_GET_SDSTAT		14	/* Get SD status */
+#define ISDIO_READ			55	/* Read data form SD iSDIO register */
+#define ISDIO_WRITE			56	/* Write data to SD iSDIO register */
+#define ISDIO_MRITE			57	/* Masked write data to SD iSDIO register */
+
+/* ATA/CF specific ioctl command */
+#define ATA_GET_REV			20	/* Get F/W revision */
+#define ATA_GET_MODEL		21	/* Get model name */
+#define ATA_GET_SN			22	/* Get serial number */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

stm-firmware/include/fatfs/ff.h

@@ -0,0 +1,426 @@
+/*----------------------------------------------------------------------------/
+/  FatFs - Generic FAT Filesystem module  R0.14                               /
+/-----------------------------------------------------------------------------/
+/
+/ Copyright (C) 2019, 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
+/ that the following condition is met:
+
+/ 1. Redistributions of source code must retain the above copyright notice,
+/    this condition and the following disclaimer.
+/
+/ This software is provided by the copyright holder and contributors "AS IS"
+/ and any warranties related to this software are DISCLAIMED.
+/ The copyright owner or contributors be NOT LIABLE for any damages caused
+/ by use of this software.
+/
+/----------------------------------------------------------------------------*/
+
+
+#ifndef FF_DEFINED
+#define FF_DEFINED	86606	/* Revision ID */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ffconf.h"		/* FatFs configuration options */
+
+#if FF_DEFINED != FFCONF_DEF
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+/* Integer types used for FatFs API */
+
+#if defined(_WIN32)	/* Main development platform */
+#define FF_INTDEF 2
+#include <windows.h>
+typedef unsigned __int64 QWORD;
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus)	/* C99 or later */
+#define FF_INTDEF 2
+#include <stdint.h>
+typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
+typedef unsigned char	BYTE;	/* char must be 8-bit */
+typedef uint16_t		WORD;	/* 16-bit unsigned integer */
+typedef uint32_t		DWORD;	/* 32-bit unsigned integer */
+typedef uint64_t		QWORD;	/* 64-bit unsigned integer */
+typedef WORD			WCHAR;	/* UTF-16 character type */
+#else  	/* Earlier than C99 */
+#define FF_INTDEF 1
+typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
+typedef unsigned char	BYTE;	/* char must be 8-bit */
+typedef unsigned short	WORD;	/* 16-bit unsigned integer */
+typedef unsigned long	DWORD;	/* 32-bit unsigned integer */
+typedef WORD			WCHAR;	/* UTF-16 character type */
+#endif
+
+
+/* Definitions of volume management */
+
+#if FF_MULTI_PARTITION		/* Multiple partition configuration */
+typedef struct {
+	BYTE pd;	/* Physical drive number */
+	BYTE pt;	/* Partition: 0:Auto detect, 1-4:Forced partition) */
+} PARTITION;
+extern PARTITION VolToPart[];	/* Volume - Partition mapping table */
+#endif
+
+#if FF_STR_VOLUME_ID
+#ifndef FF_VOLUME_STRS
+extern const char* VolumeStr[FF_VOLUMES];	/* User defied volume ID */
+#endif
+#endif
+
+
+
+/* Type of path name strings on FatFs API */
+
+#ifndef _INC_TCHAR
+#define _INC_TCHAR
+
+#if FF_USE_LFN && FF_LFN_UNICODE == 1 	/* Unicode in UTF-16 encoding */
+typedef WCHAR TCHAR;
+#define _T(x) L ## x
+#define _TEXT(x) L ## x
+#elif FF_USE_LFN && FF_LFN_UNICODE == 2	/* Unicode in UTF-8 encoding */
+typedef char TCHAR;
+#define _T(x) u8 ## x
+#define _TEXT(x) u8 ## x
+#elif FF_USE_LFN && FF_LFN_UNICODE == 3	/* Unicode in UTF-32 encoding */
+typedef DWORD TCHAR;
+#define _T(x) U ## x
+#define _TEXT(x) U ## x
+#elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
+#error Wrong FF_LFN_UNICODE setting
+#else									/* ANSI/OEM code in SBCS/DBCS */
+typedef char TCHAR;
+#define _T(x) x
+#define _TEXT(x) x
+#endif
+
+#endif
+
+
+
+/* Type of file size and LBA variables */
+
+#if FF_FS_EXFAT
+#if FF_INTDEF != 2
+#error exFAT feature wants C99 or later
+#endif
+typedef QWORD FSIZE_t;
+#if FF_LBA64
+typedef QWORD LBA_t;
+#else
+typedef DWORD LBA_t;
+#endif
+#else
+#if FF_LBA64
+#error exFAT needs to be enabled when enable 64-bit LBA
+#endif
+typedef DWORD FSIZE_t;
+typedef DWORD LBA_t;
+#endif
+
+
+
+/* Filesystem object structure (FATFS) */
+
+typedef struct {
+	BYTE	fs_type;		/* Filesystem type (0:not mounted) */
+	BYTE	pdrv;			/* Associated physical drive */
+	BYTE	n_fats;			/* Number of FATs (1 or 2) */
+	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] */
+#if FF_MAX_SS != FF_MIN_SS
+	WORD	ssize;			/* Sector size (512, 1024, 2048 or 4096) */
+#endif
+#if FF_USE_LFN
+	WCHAR*	lfnbuf;			/* LFN working buffer */
+#endif
+#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 */
+#endif
+#if FF_FS_RPATH
+	DWORD	cdir;			/* Current directory start cluster (0:root) */
+#if FF_FS_EXFAT
+	DWORD	cdc_scl;		/* Containing directory start cluster (invalid when cdir is 0) */
+	DWORD	cdc_size;		/* b31-b8:Size of containing directory, b7-b0: Chain status */
+	DWORD	cdc_ofs;		/* Offset in the containing directory (invalid when cdir is 0) */
+#endif
+#endif
+	DWORD	n_fatent;		/* Number of FAT entries (number of clusters + 2) */
+	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/cluster */
+	LBA_t	database;		/* Data base sector */
+#if FF_FS_EXFAT
+	LBA_t	bitbase;		/* Allocation bitmap base sector */
+#endif
+	LBA_t	winsect;		/* Current sector appearing in the win[] */
+	BYTE	win[FF_MAX_SS];	/* Disk access window for Directory, FAT (and file data at tiny cfg) */
+} FATFS;
+
+
+
+/* Object ID and allocation information (FFOBJID) */
+
+typedef struct {
+	FATFS*	fs;				/* Pointer to the hosting volume of this object */
+	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) */
+	FSIZE_t	objsize;		/* Object size (valid when sclust != 0) */
+#if FF_FS_EXFAT
+	DWORD	n_cont;			/* Size of first fragment - 1 (valid when stat == 3) */
+	DWORD	n_frag;			/* Size of last fragment needs to be written to FAT (valid when not zero) */
+	DWORD	c_scl;			/* Containing directory start cluster (valid when sclust != 0) */
+	DWORD	c_size;			/* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */
+	DWORD	c_ofs;			/* Offset in the containing directory (valid when file object and sclust != 0) */
+#endif
+#if FF_FS_LOCK
+	UINT	lockid;			/* File lock ID origin from 1 (index of file semaphore table Files[]) */
+#endif
+} FFOBJID;
+
+
+
+/* File object structure (FIL) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier (must be the 1st member to detect invalid object pointer) */
+	BYTE	flag;			/* File status flags */
+	BYTE	err;			/* Abort flag (error code) */
+	FSIZE_t	fptr;			/* File read/write pointer (Zeroed on file open) */
+	DWORD	clust;			/* Current cluster of fpter (invalid when fptr is 0) */
+	LBA_t	sect;			/* Sector number appearing in buf[] (0:invalid) */
+#if !FF_FS_READONLY
+	LBA_t	dir_sect;		/* Sector number containing the directory entry (not used at exFAT) */
+	BYTE*	dir_ptr;		/* Pointer to the directory entry in the win[] (not used at exFAT) */
+#endif
+#if FF_USE_FASTSEEK
+	DWORD*	cltbl;			/* Pointer to the cluster link map table (nulled on open, set by application) */
+#endif
+#if !FF_FS_TINY
+	BYTE	buf[FF_MAX_SS];	/* File private data read/write window */
+#endif
+} FIL;
+
+
+
+/* Directory object structure (DIR) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier */
+	DWORD	dptr;			/* Current read/write offset */
+	DWORD	clust;			/* Current cluster */
+	LBA_t	sect;			/* Current sector (0:Read operation has terminated) */
+	BYTE*	dir;			/* Pointer to the directory item in the win[] */
+	BYTE	fn[12];			/* SFN (in/out) {body[8],ext[3],status[1]} */
+#if FF_USE_LFN
+	DWORD	blk_ofs;		/* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
+#endif
+#if FF_USE_FIND
+	const TCHAR* pat;		/* Pointer to the name matching pattern */
+#endif
+} DIR;
+
+
+
+/* File information structure (FILINFO) */
+
+typedef struct {
+	FSIZE_t	fsize;			/* File size */
+	WORD	fdate;			/* Modified date */
+	WORD	ftime;			/* Modified time */
+	BYTE	fattrib;		/* File attribute */
+#if FF_USE_LFN
+	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 */
+#endif
+} FILINFO;
+
+
+
+/* Format parameter structure (MKFS_PARM) */
+
+typedef struct {
+	BYTE fmt;			/* Format option (FM_FAT, FM_FAT32, FM_EXFAT and FM_SFD) */
+	BYTE n_fat;			/* Number of FATs */
+	UINT align;			/* Data area alignment (sector) */
+	UINT n_root;		/* Number of root directory entries */
+	DWORD au_size;		/* Cluster size (byte) */
+} MKFS_PARM;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+	FR_OK = 0,				/* (0) Succeeded */
+	FR_DISK_ERR,			/* (1) A hard error occurred in the low level disk I/O layer */
+	FR_INT_ERR,				/* (2) Assertion failed */
+	FR_NOT_READY,			/* (3) The physical drive cannot work */
+	FR_NO_FILE,				/* (4) Could not find the file */
+	FR_NO_PATH,				/* (5) Could not find the path */
+	FR_INVALID_NAME,		/* (6) The path name format is invalid */
+	FR_DENIED,				/* (7) Access denied due to prohibited access or directory full */
+	FR_EXIST,				/* (8) Access denied due to prohibited access */
+	FR_INVALID_OBJECT,		/* (9) The file/directory object is invalid */
+	FR_WRITE_PROTECTED,		/* (10) The physical drive is write protected */
+	FR_INVALID_DRIVE,		/* (11) The logical drive number is invalid */
+	FR_NOT_ENABLED,			/* (12) The volume has no work area */
+	FR_NO_FILESYSTEM,		/* (13) There is no valid FAT volume */
+	FR_MKFS_ABORTED,		/* (14) The f_mkfs() aborted due to any problem */
+	FR_TIMEOUT,				/* (15) Could not get a grant to access the volume within defined period */
+	FR_LOCKED,				/* (16) The operation is rejected according to the file sharing policy */
+	FR_NOT_ENOUGH_CORE,		/* (17) LFN working buffer could not be allocated */
+	FR_TOO_MANY_OPEN_FILES,	/* (18) Number of open files > FF_FS_LOCK */
+	FR_INVALID_PARAMETER	/* (19) Given parameter is invalid */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* 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 */
+FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);			/* Read data from the file */
+FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to the file */
+FRESULT f_lseek (FIL* fp, FSIZE_t ofs);								/* Move file pointer of the file object */
+FRESULT f_truncate (FIL* fp);										/* Truncate the file */
+FRESULT f_sync (FIL* fp);											/* Flush cached data of the writing file */
+FRESULT f_opendir (DIR* dp, const TCHAR* path);						/* Open a directory */
+FRESULT f_closedir (DIR* dp);										/* Close an open directory */
+FRESULT f_readdir (DIR* dp, FILINFO* fno);							/* Read a directory item */
+FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);	/* Find first file */
+FRESULT f_findnext (DIR* dp, FILINFO* fno);							/* Find next file */
+FRESULT f_mkdir (const TCHAR* path);								/* Create a sub directory */
+FRESULT f_unlink (const TCHAR* path);								/* Delete an existing file or directory */
+FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);	/* Rename/Move a file or directory */
+FRESULT f_stat (const TCHAR* path, FILINFO* fno);					/* Get file status */
+FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);			/* Change attribute of a file/dir */
+FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change timestamp of a file/dir */
+FRESULT f_chdir (const TCHAR* path);								/* Change current directory */
+FRESULT f_chdrive (const TCHAR* path);								/* Change current drive */
+FRESULT f_getcwd (TCHAR* buff, UINT len);							/* Get current directory */
+FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);	/* Get number of free clusters on the drive */
+FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);	/* Get volume label */
+FRESULT f_setlabel (const TCHAR* label);							/* Set volume label */
+FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);	/* Forward data to the stream */
+FRESULT f_expand (FIL* fp, FSIZE_t fsz, BYTE opt);					/* Allocate a contiguous block to the file */
+FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);			/* Mount/Unmount a logical drive */
+FRESULT f_mkfs (const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len);	/* Create a FAT volume */
+FRESULT f_fdisk (BYTE pdrv, const LBA_t ptbl[], void* work);		/* Divide a physical drive into some partitions */
+FRESULT f_setcp (WORD cp);											/* Set current code page */
+int f_putc (TCHAR c, FIL* fp);										/* Put a character to the file */
+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 */
+
+#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
+#define f_error(fp) ((fp)->err)
+#define f_tell(fp) ((fp)->fptr)
+#define f_size(fp) ((fp)->obj.objsize)
+#define f_rewind(fp) f_lseek((fp), 0)
+#define f_rewinddir(dp) f_readdir((dp), 0)
+#define f_rmdir(path) f_unlink(path)
+#define f_unmount(path) f_mount(0, path, 0)
+
+#ifndef EOF
+#define EOF (-1)
+#endif
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Additional user defined functions                            */
+
+/* RTC function */
+#if !FF_FS_READONLY && !FF_FS_NORTC
+DWORD get_fattime (void);
+#endif
+
+/* 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
+#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
+
+/* 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                                     */
+
+
+/* File access mode and open method flags (3rd argument of f_open) */
+#define	FA_READ				0x01
+#define	FA_WRITE			0x02
+#define	FA_OPEN_EXISTING	0x00
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define	FA_OPEN_APPEND		0x30
+
+/* Fast seek controls (2nd argument of f_lseek) */
+#define CREATE_LINKMAP	((FSIZE_t)0 - 1)
+
+/* Format options (2nd argument of f_mkfs) */
+#define FM_FAT		0x01
+#define FM_FAT32	0x02
+#define FM_EXFAT	0x04
+#define FM_ANY		0x07
+#define FM_SFD		0x08
+
+/* Filesystem type (FATFS.fs_type) */
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
+#define FS_EXFAT	4
+
+/* File attribute bits for directory entry (FILINFO.fattrib) */
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FF_DEFINED */

stm-firmware/include/fatfs/ffconf.h

@@ -0,0 +1,298 @@
+/*---------------------------------------------------------------------------/
+/  FatFs Functional Configurations
+/---------------------------------------------------------------------------*/
+
+#define FFCONF_DEF	86606	/* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_READONLY	0
+/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
+/  Read-only configuration removes writing API functions, f_write(), f_sync(),
+/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
+/  and optional writing functions as well. */
+
+
+#define FF_FS_MINIMIZE	0
+/* This option defines minimization level to remove some basic API functions.
+/
+/   0: Basic functions are fully enabled.
+/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
+/      are removed.
+/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
+/   3: f_lseek() function is removed in addition to 2. */
+
+
+#define FF_USE_STRFUNC	1
+/* This option switches string functions, f_gets(), f_putc(), f_puts() and f_printf().
+/
+/  0: Disable string functions.
+/  1: Enable without LF-CRLF conversion.
+/  2: Enable with LF-CRLF conversion. */
+
+
+#define FF_USE_FIND		0
+/* This option switches filtered directory read functions, f_findfirst() and
+/  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
+
+
+#define FF_USE_MKFS		0
+/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FASTSEEK	0
+/* This option switches fast seek function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_EXPAND	0
+/* This option switches f_expand function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_CHMOD	0
+/* This option switches attribute manipulation functions, f_chmod() and f_utime().
+/  (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */
+
+
+#define FF_USE_LABEL	0
+/* This option switches volume label functions, f_getlabel() and f_setlabel().
+/  (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FORWARD	0
+/* This option switches f_forward() function. (0:Disable or 1:Enable) */
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_CODE_PAGE	850
+/* This option specifies the OEM code page to be used on the target system.
+/  Incorrect code page setting can cause a file open failure.
+/
+/   437 - U.S.
+/   720 - Arabic
+/   737 - Greek
+/   771 - KBL
+/   775 - Baltic
+/   850 - Latin 1
+/   852 - Latin 2
+/   855 - Cyrillic
+/   857 - Turkish
+/   860 - Portuguese
+/   861 - Icelandic
+/   862 - Hebrew
+/   863 - Canadian French
+/   864 - Arabic
+/   865 - Nordic
+/   866 - Russian
+/   869 - Greek 2
+/   932 - Japanese (DBCS)
+/   936 - Simplified Chinese (DBCS)
+/   949 - Korean (DBCS)
+/   950 - Traditional Chinese (DBCS)
+/     0 - Include all code pages above and configured by f_setcp()
+*/
+
+
+#define FF_USE_LFN		1
+#define FF_MAX_LFN		255
+/* The FF_USE_LFN switches the support for LFN (long file name).
+/
+/   0: Disable LFN. FF_MAX_LFN has no effect.
+/   1: Enable LFN with static  working buffer on the BSS. Always NOT thread-safe.
+/   2: Enable LFN with dynamic working buffer on the STACK.
+/   3: Enable LFN with dynamic working buffer on the HEAP.
+/
+/  To enable the LFN, ffunicode.c needs to be added to the project. The LFN function
+/  requiers certain internal working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
+/  additional (FF_MAX_LFN + 44) / 15 * 32 bytes when exFAT is enabled.
+/  The FF_MAX_LFN defines size of the working buffer in UTF-16 code unit and it can
+/  be in range of 12 to 255. It is recommended to be set it 255 to fully support LFN
+/  specification.
+/  When use stack for the working buffer, take care on stack overflow. When use heap
+/  memory for the working buffer, memory management functions, ff_memalloc() and
+/  ff_memfree() exemplified in ffsystem.c, need to be added to the project. */
+
+
+#define FF_LFN_UNICODE	0
+/* This option switches the character encoding on the API when LFN is enabled.
+/
+/   0: ANSI/OEM in current CP (TCHAR = char)
+/   1: Unicode in UTF-16 (TCHAR = WCHAR)
+/   2: Unicode in UTF-8 (TCHAR = char)
+/   3: Unicode in UTF-32 (TCHAR = DWORD)
+/
+/  Also behavior of string I/O functions will be affected by this option.
+/  When LFN is not enabled, this option has no effect. */
+
+
+#define FF_LFN_BUF		255
+#define FF_SFN_BUF		12
+/* This set of options defines size of file name members in the FILINFO structure
+/  which is used to read out directory items. These values should be suffcient for
+/  the file names to read. The maximum possible length of the read file name depends
+/  on character encoding. When LFN is not enabled, these options have no effect. */
+
+
+#define FF_STRF_ENCODE	3
+/* When FF_LFN_UNICODE >= 1 with LFN enabled, string I/O functions, f_gets(),
+/  f_putc(), f_puts and f_printf() convert the character encoding in it.
+/  This option selects assumption of character encoding ON THE FILE to be
+/  read/written via those functions.
+/
+/   0: ANSI/OEM in current CP
+/   1: Unicode in UTF-16LE
+/   2: Unicode in UTF-16BE
+/   3: Unicode in UTF-8
+*/
+
+
+#define FF_FS_RPATH		0
+/* This option configures support for relative path.
+/
+/   0: Disable relative path and remove related functions.
+/   1: Enable relative path. f_chdir() and f_chdrive() are available.
+/   2: f_getcwd() function is available in addition to 1.
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ Drive/Volume Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_VOLUMES		1
+/* Number of volumes (logical drives) to be used. (1-10) */
+
+
+#define FF_STR_VOLUME_ID	1
+#define FF_VOLUME_STRS		"SD"
+/* FF_STR_VOLUME_ID switches support for volume ID in arbitrary strings.
+/  When FF_STR_VOLUME_ID is set to 1 or 2, arbitrary strings can be used as drive
+/  number in the path name. FF_VOLUME_STRS defines the volume ID strings for each
+/  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 needs to be defined as:
+/
+/  const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
+*/
+
+
+#define FF_MULTI_PARTITION	0
+/* This option switches support for multiple volumes on the physical drive.
+/  By default (0), each logical drive number is bound to the same physical drive
+/  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()
+/  funciton will be available. */
+
+
+#define FF_MIN_SS		512
+#define FF_MAX_SS		512
+/* This set of options configures the range of sector size to be supported. (512,
+/  1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
+/  harddisk. But a larger value may be required for on-board flash memory and some
+/  type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
+/  for variable sector size mode and disk_ioctl() function needs to implement
+/  GET_SECTOR_SIZE command. */
+
+
+#define FF_LBA64		0
+/* This option switches support for 64-bit LBA. (0:Disable or 1:Enable)
+/  To enable the 64-bit LBA, also exFAT needs to be enabled. (FF_FS_EXFAT == 1) */
+
+
+#define FF_MIN_GPT		0x100000000
+/* Minimum number of sectors to switch GPT format to create partition in f_mkfs and
+/  f_fdisk function. 0x100000000 max. This option has no effect when FF_LBA64 == 0. */
+
+
+#define FF_USE_TRIM		0
+/* This option switches support for ATA-TRIM. (0:Disable or 1:Enable)
+/  To enable Trim function, also CTRL_TRIM command should be implemented to the
+/  disk_ioctl() function. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_TINY		0
+/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
+/  At the tiny configuration, size of file object (FIL) is shrinked FF_MAX_SS bytes.
+/  Instead of private sector buffer eliminated from the file object, common sector
+/  buffer in the filesystem object (FATFS) is used for the file data transfer. */
+
+
+#define FF_FS_EXFAT		0
+/* This option switches support for exFAT filesystem. (0:Disable or 1:Enable)
+/  To enable exFAT, also LFN needs to be enabled. (FF_USE_LFN >= 1)
+/  Note that enabling exFAT discards ANSI C (C89) compatibility. */
+
+
+#define FF_FS_NORTC		0
+#define FF_NORTC_MON	1
+#define FF_NORTC_MDAY	1
+#define FF_NORTC_YEAR	2019
+/* 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,
+/  FF_NORTC_MDAY and FF_NORTC_YEAR have no effect.
+/  These options have no effect in read-only configuration (FF_FS_READONLY = 1). */
+
+
+#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 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.
+/  bit0=1: Do not trust free cluster count in the FSINFO.
+/  bit1=0: Use last allocated cluster number in the FSINFO if available.
+/  bit1=1: Do not trust last allocated cluster number in the FSINFO.
+*/
+
+
+#define FF_FS_LOCK		0
+/* The option FF_FS_LOCK switches file lock function to control duplicated file open
+/  and illegal operation to open objects. This option must be 0 when FF_FS_READONLY
+/  is 1.
+/
+/  0:  Disable file lock function. To avoid volume corruption, application program
+/      should avoid illegal open, remove and rename to the open objects.
+/  >0: Enable file lock function. The value defines how many files/sub-directories
+/      can be opened simultaneously under file lock control. Note that the file
+/      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 function.
+/
+/   0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
+/   1: Enable re-entrancy. Also user provided synchronization handlers,
+/      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 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. */
+
+
+
+/*--- End of configuration options ---*/

stm-firmware/include/reflow-controller/adc-meas.h

@@ -24,6 +24,11 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stm32/stm32f4xx.h>
+
+/*If this is changed, change DMA code to fit the channel assignment! */
+#define ADC_PT1000_PERIPH ADC3
+#define ADC_PT1000_DMA2_STREAM0_CHANNEL 2
+
 /**
  * @brief Moving average filter coefficient for PT1000 measurement
  */
@@ -34,15 +39,35 @@
  */
 #define ADC_PT1000_CHANNEL 2U
 
+/**
+ * @brief GPIO Port the ADC converter for the PT1000 measurement is connected to
+ */
 #define ADC_PT1000_PORT GPIOA
+
+/**
+ * @brief The clock enable mask of the RCC register for ADC_PT1000_PORT
+ */
 #define ADC_PT1000_PORT_RCC_MASK RCC_AHB1ENR_GPIOAEN
 
+/**
+ * @brief The GPIO pin number the PT1000 analog voltage is connected to
+ */
 #define ADC_PT1000_PIN 2U
 
+/**
+ * @brief The cycle count the moving average filter is labeled 'instable' after startup of the measurement or changing
+ * the alpha value @ref ADC_PT1000_FILTER_WEIGHT
+ */
 #define ADC_FILTER_STARTUP_CYCLES 800U
 
+/**
+ * @brief The delay value programmed into the sample timer
+ */
 #define ADC_PT1000_SAMPLE_CNT_DELAY 1000U
 
+/**
+ * @brief The amount of samples to take to prefilter the analog signal
+ */
 #define ADC_PT1000_DMA_AVG_SAMPLES 6U
 
 /**
@@ -59,6 +84,12 @@
  */
 #define ADC_PT1000_UPPER_WATCHDOG 4000U
 
+/**
+ * @brief Number of ADC samples the value has to be outside the Watchdog limit (@ref ADC_PT1000_UPPER_WATCHDOG and @ref ADC_PT1000_LOWER_WATCHDOG)
+ * in order to produce a watchdog error
+ */
+#define ADC_PT1000_WATCHDOG_SAMPLE_COUNT 25U
+
 enum adc_pt1000_error {ADC_PT1000_NO_ERR= 0, ADC_PT1000_WATCHDOG_ERROR=(1UL<<0), ADC_PT1000_OVERFLOW=(1UL<<1), ADC_PT1000_INACTIVE = (1UL<<2)};
 
 /**
@@ -107,7 +138,7 @@ void adc_pt1000_get_resistance_calibration(float *offset, float *sensitivity_dev
 /**
  * @brief Get the current reistance value
  *
- * If the reistance calibration is enabled, this function applies the calculations of the raw reistance reading and
+ * If the reistance calibration is enabled, this function applies the calculations of the raw resistance reading and
  * returns the corrected value.
  *
  * If an ADC error is set, the status is negative. The status is 2 during the first measurements with a given filter setting. Technically, the resistance value is
@@ -138,8 +169,14 @@ void adc_pt1000_convert_raw_value_array_to_resistance(float *resistance_dest, fl
  */
 enum adc_pt1000_error adc_pt1000_check_error();
 
+/**
+ * @brief Clear the error status of the PT1000 measurement
+ */
 void adc_pt1000_clear_error();
 
+/**
+ * @brief Disable the PT1000 measurement
+ */
 void adc_pt1000_disable();
 
 #endif // __ADCMEAS_H__

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

@@ -0,0 +1,76 @@
+/* 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/>.
+*/
+
+#ifndef __BUTTON_H__
+#define __BUTTON_H__
+
+/**
+ * @brief GPIO Port the button is connected to
+ */
+#define BUTTON_PORT GPIOD
+
+/**
+ * @brief The RCC clock mask for @ref BUTTON_PORT
+ */
+#define BUTTON_RCC_MASK RCC_AHB1ENR_GPIODEN
+
+/**
+ * @brief The GPIO pin number the button is connected to
+ */
+#define BUTTON_PIN 4
+
+/**
+ * @brief The time in ms the button has to stay pressed to be detected as a short press
+ */
+#define BUTTON_SHORT_ON_TIME_MS 50UL
+
+/**
+ * @brief Time in ms the button has to be pressed to be counted as a long press
+ */
+#define BUTTON_LONG_ON_TIME_MS 400UL
+
+
+#if BUTTON_LONG_ON_TIME_MS <= BUTTON_SHORT_ON_TIME_MS
+#error "Button BUTTON_SHORT_ON_TIME_MS time has to be shorter than BUTTON_LONG_ON_TIME_MS"
+#endif
+
+/**
+ * @brief States the puhsbutton of the rotary encoder can be in
+ */
+enum button_state {BUTTON_IDLE = 0, BUTTON_SHORT_RELEASED, BUTTON_LONG_RELEASED, BUTTON_SHORT, BUTTON_LONG};
+
+/**
+ * @brief Init the push button
+ */
+void button_init();
+
+/**
+ * @brief read if a push button event occured
+ * @return Button event
+ */
+enum button_state button_read_event();
+
+/**
+ * @brief button_deinit
+ */
+void button_deinit();
+
+
+#endif /* __BUTTON_H__ */

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

@@ -29,8 +29,8 @@
 void calibration_calculate(float low_measured, float low_setpoint, float high_measured, float high_setpoint,
 			   float *sens_deviation, float *sens_corrected_offset);
 
-int calibration_acquire_data(float *mu, float *max_dev, uint32_t count);
+float *calibration_acquire_data_start(uint32_t count, volatile int *flag);
 
-int calibration_sequence_shell_cmd(shellmatta_handle_t shell);
+shellmatta_retCode_t calibration_sequence_shell_cmd(shellmatta_handle_t shell, const char *arg, uint32_t len);
 
 #endif /* __CALIBRATION_H__ */

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

@@ -58,10 +58,11 @@ int led_get(uint8_t num);
 #define LOUDSPEAKER_PORT GPIOB
 #define LOUDSPEAKER_RCC_MASK RCC_AHB1ENR_GPIOBEN
 #define LOUDSPEAKER_PIN 1
+#define LOUDSPEAKER_MULTIFREQ 1
 
 void loudspeaker_setup();
-void loudspeaker_set(int val);
+void loudspeaker_set(uint16_t val);
-int loudspeaker_get();
+uint16_t loudspeaker_get();
 
 
 #endif /* __DIGIO_H__ */

stm-firmware/include/reflow-controller/oven-driver.h

@@ -0,0 +1,73 @@
+/* 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/>.
+*/
+
+#ifndef __OVEN_DRIVER_H__
+#define __OVEN_DRIVER_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <reflow-controller/pid-controller.h>
+
+enum oven_pid_error_report {
+	OVEN_PID_NO_ERROR = 0,
+	OVEN_PID_ERR_PT1000_ADC_WATCHDOG = (1<<0),
+	OVEN_PID_ERR_PT1000_ADC_OFF = (1<<1),
+	OVEN_PID_ERR_PT1000_OTHER = (1<<2),
+	OVEN_PID_ERR_VREF_TOL = (1<<3),
+	OVEN_PID_ERR_OVERTEMP = (1<<4),
+};
+
+struct oven_pid_errors {
+	bool generic_error;
+	bool pt1000_adc_watchdog;
+	bool pt1000_adc_off;
+	bool pt1000_other;
+	bool vref_tol;
+	bool controller_overtemp;
+};
+
+struct oven_pid_status {
+	bool active;
+	bool error_set;
+	struct oven_pid_errors error_flags;
+	float target_temp;
+	float current_temp;
+	uint64_t timestamp_last_run;
+};
+
+void oven_driver_init(void);
+
+void oven_driver_set_power(uint8_t power);
+
+void oven_driver_disable(void);
+
+void oven_pid_ack_errors(void);
+
+void oven_pid_init(struct pid_controller *controller_to_copy);
+
+void oven_pid_handle(float target_temp);
+
+void oven_pid_stop();
+
+void oven_pid_report_error(enum oven_pid_error_report report);
+
+const struct oven_pid_status *oven_pid_get_status(void);
+
+#endif /* __OVEN_DRIVER_H__ */

stm-firmware/include/reflow-controller/periph-config/oven-driver-hwcfg.h

@@ -0,0 +1,33 @@
+/* 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/>.
+*/
+
+#ifndef __OVEN_DRIVER_HWCFG_H__
+#define __OVEN_DRIVER_HWCFG_H__
+
+#include <stm32/stm32f4xx.h>
+
+#define OVEN_CONTROLLER_PWM_TIMER TIM3
+#define OVEN_CONTROLLER_PORT GPIOB
+#define OVEN_CONTROLLER_PIN (0)
+#define OVEN_CONTROLLER_PORT_RCC_MASK RCC_AHB1ENR_GPIOBEN
+#define OVEN_CONTROLLER_TIM_RCC_MASK RCC_APB1ENR_TIM3EN
+#define OVEN_CONTROLLER_PIN_ALTFUNC (2)
+
+#endif /* __OVEN_DRIVER_HWCFG_H__ */

stm-firmware/include/reflow-controller/periph-config/safety-adc-hwcfg.h

@@ -0,0 +1,38 @@
+/* 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/>.
+*/
+
+#ifndef __SAFETY_ADC_HWCFG_H__
+#define __SAFETY_ADC_HWCFG_H__
+
+#include <stm32/stm32f4xx.h>
+
+#define SAFETY_ADC_ADC_PERIPHERAL ADC1
+#define SAFETY_ADC_ADC_RCC_MASK RCC_APB2ENR_ADC1EN
+#define TEMP_CHANNEL_NUM (16)
+#define INT_REF_CHANNEL_NUM (17)
+
+#define SAFETY_ADC_INT_REF_MV 1210.0f
+
+#define SAFETY_ADC_TEMP_NOM 25.0f
+#define SAFETY_ADC_TEMP_NOM_MV 760.0f
+#define SAFETY_ADC_TEMP_MV_SLOPE 2.5f
+
+
+#endif /* __SAFETY_ADC_HWCFG_H__ */

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

@@ -0,0 +1,50 @@
+/* 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/>.
+*/
+
+#ifndef __PID_CONTROLLER_H__
+#define __PID_CONTROLLER_H__
+
+struct pid_controller {
+	float k_deriv;
+	float k_int;
+	float k_p;
+	float k_int_t;
+	float k_deriv_t;
+	float output_sat_max;
+	float output_sat_min;
+	float integral_max;
+	float sample_period;
+	volatile float control_output;
+	volatile float last_in;
+	volatile float integral;
+	volatile float derivate;
+};
+
+void pid_init(struct pid_controller *pid, float k_deriv, float k_int, float k_p, float output_sat_min, float output_sat_max, float integral_max, float sample_period);
+
+void pid_zero(struct pid_controller *pid);
+
+float pid_sample(struct pid_controller *pid, float deviation);
+
+float pid_get_control_output(const struct pid_controller *pid);
+
+int pid_copy(struct pid_controller *dest, const struct pid_controller *src);
+
+#endif /* __PID_CONTROLLER_H__ */

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

@@ -0,0 +1,32 @@
+/* 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/>.
+*/
+
+#ifndef __REFLOW_MENU_H__
+#define __REFLOW_MENU_H__
+
+/**
+ * @brief Handle the reflow controller's LCD Menu
+ * @return 0 if no delay is requested, 1 if delay is requested
+ */
+int reflow_menu_handle(void);
+
+void reflow_menu_init(void);
+
+#endif /* __REFLOW_MENU_H__ */

stm-firmware/include/reflow-controller/rotary-encoder.h

@@ -39,4 +39,6 @@ int32_t rotary_encoder_get_change_val(void);
 
 void rotary_encoder_stop(void);
 
+void rotary_encoder_zero(void);
+
 #endif /* __ROTARY_ENCODER_H__ */

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

@@ -0,0 +1,70 @@
+/* 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/>.
+*/
+
+#ifndef __SAFETY_ADC_H__
+#define __SAFETY_ADC_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define SAFETY_ADC_VREF_MVOLT (2500.0f)
+#define SAFETY_ADC_VREF_TOL_MVOLT (100.0f)
+#define SAFETY_ADC_TEMP_LOW_LIM (0.0f)
+#define SAFETY_ADC_TEMP_HIGH_LIM (65.0f)
+
+enum safety_adc_meas_channel {SAFETY_ADC_MEAS_VREF, SAFETY_ADC_MEAS_TEMP};
+enum safety_adc_check_result {
+				SAFETY_ADC_CHECK_OK = 0UL,
+				SAFETY_ADC_CHECK_VREF_LOW = (1U<<0),
+				SAFETY_ADC_CHECK_VREF_HIGH = (1U<<1),
+				SAFETY_ADC_CHECK_TEMP_LOW = (1U<<2),
+				SAFETY_ADC_CHECK_TEMP_HIGH = (1U<<3),
+				SAFETY_ADC_INTERNAL_ERROR = (1U<<4),
+				};
+
+extern enum safety_adc_check_result global_safety_adc_status;
+
+enum safety_adc_check_result safety_adc_get_errors();
+
+void safety_adc_clear_errors(void);
+
+void safety_adc_init();
+
+void safety_adc_deinit();
+
+void safety_adc_trigger_meas(enum safety_adc_meas_channel measurement);
+
+/**
+ * @brief Poll ADC result.
+ * @param results adc results
+ * @return 1 if measurement successful, 0 if not ready, -1 if ADC aborted or not started
+ */
+int safety_adc_poll_result(uint16_t *adc_result);
+
+enum safety_adc_check_result safety_adc_check_results(uint16_t vref_result, uint16_t temp_result,
+						      float *vref_calculated, float *temp_calculated);
+
+enum safety_adc_check_result handle_safety_adc();
+
+float safety_adc_get_temp();
+
+float safety_adc_get_vref();
+
+#endif /* __SAFETY_ADC_H__ */

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

@@ -0,0 +1,24 @@
+/* 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/>.
+*/
+
+#ifndef __SETTINGS_SETTINGS_SD_CARD_H__
+#define __SETTINGS_SETTINGS_SD_CARD_H__
+
+#endif /* __SETTINGS_SETTINGS_SD_CARD_H__ */

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

@@ -0,0 +1,27 @@
+/* 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/>.
+*/
+
+
+#ifndef __SETTINGS_SETTINGS_H__
+#define __SETTINGS_SETTINGS_H__
+
+int settings_save_calibration();
+
+#endif /* __SETTINGS_SETTINGS_H__ */

stm-firmware/include/reflow-controller/shell-uart-config.h

@@ -0,0 +1,33 @@
+#ifndef __SHELL_UART_CONFIG_H__
+#define __SHELL_UART_CONFIG_H__
+
+#define SHELL_UART_RECEIVE_DMA_STREAM DMA2_Stream5
+
+#define SHELL_UART_SEND_DMA_STREAM DMA2_Stream7
+
+#define SHELL_UART_PERIPH USART1
+#define SHELL_UART_RCC_REG RCC->APB2ENR
+#define SHELL_UART_RCC_MASK RCC_APB2ENR_USART1EN
+
+#define SHELL_UART_RX_DMA_TRIGGER 4U
+#define SHELL_UART_TX_DMA_TRIGGER 4U
+
+#ifdef DEBUGBUILD
+
+#define SHELL_UART_PORT GPIOA
+#define SHELL_UART_PORT_RCC_MASK RCC_AHB1ENR_GPIOAEN
+#define SHELL_UART_RX_PIN 10
+#define SHELL_UART_TX_PIN 9
+#define SHELL_UART_RX_PIN_ALTFUNC 7
+#define SHELL_UART_TX_PIN_ALTFUNC 7
+#else
+
+#endif
+
+/* UART_DIV is 45.5625 => 115200 @ 84 MHz */
+#define SHELL_UART_DIV_FRACTION 9U /* Equals 9/16 = 0.5625 */
+#define SHELL_UART_DIV_MANTISSA 45U /* Equals 45 */
+
+#define SHELL_UART_BRR_REG_VALUE ((SHELL_UART_DIV_MANTISSA<<4) | SHELL_UART_DIV_FRACTION);
+
+#endif /* __SHELL_UART_CONFIG_H__ */

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

@@ -24,10 +24,12 @@
 #include <stddef.h>
 #include <shellmatta.h>
 
-shellmatta_handle_t shell_init(void);
+shellmatta_handle_t shell_init(shellmatta_write_t write_func);
 
 void shell_handle_input(shellmatta_handle_t shell, const char *data, size_t len);
 
 void shell_print_string(shellmatta_handle_t shell, const char *string);
 
+void shell_print_motd(shellmatta_handle_t shell);
+
 #endif /* __SHELL_H__ */

stm-firmware/include/reflow-controller/stack-check.h

@@ -0,0 +1,53 @@
+/* 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.
+*
+* 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 __STACK_CHECK_H__
+#define __STACK_CHECK_H__
+
+#include <stdint.h>
+
+#define STACK_CHECK_MIN_HEAP_GAP 16UL
+
+int32_t stack_check_get_usage();
+
+int32_t stack_check_get_free();
+
+static inline int stack_check_collision()
+{
+	int ret = 0;
+	int32_t free_space = stack_check_get_free();
+
+	if ((unsigned int)free_space < STACK_CHECK_MIN_HEAP_GAP) {
+			ret = -1;
+	}
+
+	return ret;
+}
+
+static inline uint32_t read_stack_pointer()
+{
+	uint32_t stack_pointer;
+
+	__asm__ __volatile__ ("mov %0, sp\n\t" : "=r"(stack_pointer) : : );
+
+	return stack_pointer;
+}
+
+#endif /* __STACK_CHECK_H__ */

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

@@ -26,14 +26,15 @@
 #define __SYSTICK_H__
 
 #include <stdint.h>
+#include <stdbool.h>
 
 /**
  * @brief Reload value for the systick timer.
  *
  * This value has to be configured to set the systick to a one milliscond tick interval
- * The default value is 168000, which results in a 1ms tick for 168 MHz CPU speed
+ * The default value is 16800, which results in a 100us tick for 168 MHz CPU speed
  */
-#define SYSTICK_RELOAD (168000UL)
+#define SYSTICK_RELOAD (16800UL)
 
 /**
  * @brief Variable used by the systick_wait_ms function
@@ -44,10 +45,15 @@ extern volatile uint32_t wait_tick_ms;
  * @brief Systemclock in milliseconds.
  *
  * This value must not be reset during the whole runtime.
- *
+ * @warning In order to use this, you must assure that the read access is atomic.
  */
 extern volatile uint64_t global_tick_ms;
 
+/**
+ * @brief Wait counter for the display. This must not be used anywhere else
+ */
+extern volatile uint32_t lcd_tick_100us;
+
 /**
  * @brief Setup the Systick timer to generate a 1 ms tick
  */
@@ -63,5 +69,10 @@ void systick_setup(void);
  */
 void systick_wait_ms(uint32_t ms);
 
+uint64_t systick_get_global_tick();
+
+void systick_get_uptime_from_tick(uint32_t *days, uint32_t *hours, uint32_t *minutes, uint32_t *seconds);
+
+bool systick_ticks_have_passed(uint64_t start_timestamp, uint64_t ticks);
 
 #endif /* __SYSTICK_H__ */

stm-firmware/include/reflow-controller/temp-converter-data.h

@@ -8,7 +8,7 @@
  * 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,
+ * 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.

stm-firmware/include/reflow-controller/ui/lcd.h

@@ -0,0 +1,53 @@
+/* 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/>.
+*/
+
+#ifndef __LCD_H__
+#define __LCD_H__
+
+#define LCD_DPORT		(GPIOD)
+#define LCD_RCC_MASK		RCC_AHB1ENR_GPIODEN
+#define LCD_DATA_BIT_OFFSET	(8)
+#define LCD_RS			(6)
+#define LCD_E			(7)
+
+#define LCD_DATA_MASK		(0xFU << LCD_DATA_BIT_OFFSET)
+#define	LCD_RS_MASK		(1U << LCD_RS)
+#define	LCD_E_MASK		(1U << LCD_E)
+
+
+
+#define LCD_CHAR_WIDTH 16
+#define LCD_ROW_COUNT 4
+
+#define LCD_SHIMATTA_STRING "\xBC\xCF\xAF\xC0"
+#define LCD_DEGREE_SYMBOL_STRING "\xDF"
+#define LCD_DEGREE_SYMBOL_CHAR '\xDF'
+
+enum lcd_fsm_ret {LCD_FSM_NOP, LCD_FSM_CALL_AGAIN, LCD_FSM_WAIT_CALL};
+
+void lcd_init(void);
+
+void lcd_string(const char *data);
+
+void lcd_home(void);
+
+enum lcd_fsm_ret lcd_fsm_write_buffer(const char (*display_buffer)[21]);
+
+#endif /* __LCD_H__ */

stm-firmware/include/reflow-controller/ui/menu.h

@@ -0,0 +1,87 @@
+/* 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/>.
+*/
+
+#ifndef __MENU_H__
+#define __MENU_H__
+
+#include <stdint.h>
+#include <reflow-controller/button.h>
+#include <stdbool.h>
+
+struct lcd_menu;
+
+enum menu_entry_func_entry {MENU_ENTRY_FIRST_ENTER, MENU_ENTRY_CONTINUE, MENU_ENTRY_DROPBACK};
+
+typedef void (*menu_func_t)(struct lcd_menu *menu, enum menu_entry_func_entry entry_type,
+					    void *parent);
+
+struct menu_inputs {
+	int16_t rotary_encoder_delta;
+	enum button_state push_button;
+};
+
+struct lcd_menu {
+	menu_func_t active_entry;
+	menu_func_t root_entry;
+	enum menu_entry_func_entry active_entry_type;
+	menu_func_t init_parent;
+	struct menu_inputs inputs;
+	void (*update_display)(uint8_t row, const char *data);
+};
+
+struct menu_list {
+	void (*update_display)(uint8_t row, const char *data);
+	const char * const * entry_names;
+	uint32_t entry_count;
+	uint32_t currently_selected;
+	const menu_func_t *submenu_list;
+};
+
+void menu_handle(struct lcd_menu *menu, int16_t rotary_encoder_delta, enum button_state push_button);
+
+void menu_init(struct lcd_menu *menu, menu_func_t root_node, void (*display_update)(uint8_t row, const char *data));
+
+void menu_ack_rotary_delta(struct lcd_menu *menu);
+
+void menu_display_clear(struct lcd_menu *menu);
+
+void menu_entry_dropback(struct lcd_menu *menu, menu_func_t parent_func);
+
+void menu_entry_enter(struct lcd_menu *menu, menu_func_t entry, bool handle_immediately);
+
+void menu_lcd_output(struct lcd_menu *menu, uint8_t row_num, const char *text);
+
+void menu_lcd_outputf(struct lcd_menu *menu, uint8_t row_num, const char *format, ...);
+
+void menu_list_display(struct menu_list *list, uint32_t top_row, uint32_t bottom_row);
+
+int16_t menu_get_rotary_delta(const struct lcd_menu *menu);
+
+enum button_state menu_get_button_state(const struct lcd_menu *menu);
+
+void menu_list_compute_count(struct menu_list *list);
+
+void menu_list_scroll_down(struct menu_list *list);
+
+void menu_list_scroll_up(struct menu_list *list);
+
+void menu_list_enter_selected_entry(struct menu_list *list, struct lcd_menu *menu);
+
+#endif /* __MENU_H__ */

stm-firmware/include/stm-periph/dma-ring-buffer.h

@@ -96,6 +96,14 @@ int dma_ring_buffer_periph_to_mem_get_data(struct dma_ring_buffer_to_mem *buff,
  */
 void dma_ring_buffer_periph_to_mem_stop(struct dma_ring_buffer_to_mem *buff);
 
+/**
+ * @brief Get fill level of peripheral to memory DMA ring buffer
+ * @param buff Buffer
+ * @param fill_level fill level to write data to
+ * @return 0 if success
+ */
+int dma_ring_buffer_periph_to_mem_fill_level(struct dma_ring_buffer_to_mem *buff, size_t *fill_level);
+
 /**
  * @brief Initialize ring buffer to streaming data from meory to a peripheral
  * @param[in,out] dma_buffer DMA ring buffer structure
@@ -138,6 +146,14 @@ void dma_ring_buffer_mem_to_periph_int_callback(struct dma_ring_buffer_to_periph
  */
 void dma_ring_buffer_mem_to_periph_stop(struct dma_ring_buffer_to_periph *buff);
 
+/**
+ * @brief Get fill level of mem to periph DMA ring buffer
+ * @param buff Buffer
+ * @param fill_level fill level to write data to
+ * @return 0 if success
+ */
+int dma_ring_buffer_mem_to_periph_fill_level(struct dma_ring_buffer_to_periph *buff, size_t *fill_level);
+
 /** @} */
 
 #endif /* __DMA_RING_BUFFER_H__ */

stm-firmware/include/stm-periph/stm32-gpio-macros.h

@@ -21,13 +21,16 @@
 #ifndef __STM32GPIOMACROS_H__
 #define __STM32GPIOMACROS_H__
 
-#define MODER_DELETE(pin) ~(0x3U << (pin * 2))
+#define MODER_DELETE(pin) ~(0x3U << ((pin) * 2))
-#define OUTPUT(pin)  (0x01U << (pin * 2))
+#define PUPDR_DELETE(pin) ~(0x3U << ((pin) * 2))
-#define PULLUP(pin) (0x1U << (pin* 2))
+#define OUTPUT(pin)  (0x01U << ((pin) * 2))
-#define ALTFUNC(pin) ((0x2) << (pin * 2))
+#define PULLUP(pin) (0x1U << ((pin)* 2))
-#define PINMASK(pin) ((0x3) << (pin * 2))
+#define PULLDOWN(pin) (0x2U << ((pin)* 2))
-#define SETAF(PORT,PIN,AF)  PORT->AFR[(PIN < 8 ? 0 : 1)] |= AF << ((PIN < 8 ? PIN : (PIN - 8)) * 4)
+#define ALTFUNC(pin) ((0x2) << ((pin) * 2))
-#define ANALOG(pin)  (0x03 << (pin * 2))
+#define PINMASK(pin) ((0x3) << ((pin) * 2))
+#define SETAF(PORT,PIN,AF)  PORT->AFR[((PIN) < 8 ? 0 : 1)] |= (AF) << (((PIN) < 8 ? (PIN) : ((PIN) - 8)) * 4)
+#define ANALOG(pin)  (0x03 << ((pin) * 2))
+#define OTYP_OPENDRAIN(pin) (0x1U << (pin))
 
 #define BITMASK_TO_BITNO(x) (x&0x1?0:x&0x2?1:x&0x4?2:x&0x8?3: \
 		 x&0x10?4:x&0x20?5:x&0x40?6:x&0x80?7: \

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

@@ -18,57 +18,60 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <stm32/stm32f4xx.h>
+#include <stm-periph/dma-ring-buffer.h>
 #include <stdint.h>
 #include <stddef.h>
 
 #ifndef UART_UART_H_
 #define UART_UART_H_
 
-#define UART_RECEIVE_DMA_STREAM DMA2_Stream5
+struct stm_uart {
+	USART_TypeDef *uart_dev;
+	uint32_t brr_val;
+	uint8_t base_dma_num;
+	DMA_Stream_TypeDef *dma_tx_stream;
+	uint8_t dma_tx_trigger_channel;
+	DMA_Stream_TypeDef *dma_rx_stream;
+	uint8_t dma_rx_trigger_channel;
+	char *dma_rx_buff;
+	char *dma_tx_buff;
+	size_t rx_buff_count;
+	size_t tx_buff_count;
+	volatile uint32_t *rcc_reg;
+	uint8_t rcc_bit_no;
+	struct dma_ring_buffer_to_mem rx_ring_buff;
+	struct dma_ring_buffer_to_periph tx_ring_buff;
+	uint8_t tx : 1;
+	uint8_t rx : 1;
+};
 
-#define UART_SEND_DMA_STREAM DMA2_Stream7
+int uart_init(struct stm_uart *uart);
 
-#define UART_PERIPH USART1
+void uart_change_brr(struct stm_uart *uart, uint32_t brr);
-#define UART_RCC_MASK RCC_APB2ENR_USART1EN
 
-#ifdef DEBUGBUILD
+void uart_disable(struct stm_uart *uart);
 
-#define UART_PORT GPIOA
+void uart_send_char(struct stm_uart *uart, char c);
-#define UART_PORT_RCC_MASK RCC_AHB1ENR_GPIOAEN
-#define UART_RX_PIN 10
-#define UART_TX_PIN 9
-#define UART_RX_PIN_ALTFUNC 7
-#define UART_TX_PIN_ALTFUNC 7
-#else
 
-#endif
+void uart_send_array(struct stm_uart *uart, const char *data, uint32_t len);
 
-/* UART_DIV is 45.5625 => 115200 @ 84 MHz */
+void uart_send_string(struct stm_uart *uart, const char *string);
-#define UART_DIV_FRACTION 9U /* Equals 9/16 = 0.5625 */
-#define UART_DIV_MANTISSA 45U /* Equals 45 */
 
-#define UART_BRR_REG_VALUE ((UART_DIV_MANTISSA<<4) | UART_DIV_FRACTION);
+void uart_send_array_with_dma(struct stm_uart *uart, const char *data, uint32_t len);
 
-void initUART();
+void uart_send_string_with_dma(struct stm_uart *uart, const char *string);
-void sendChar(char c);
-void sendString(char* s, int count);
 
+int uart_receive_data_with_dma(struct stm_uart *uart, const char **data, size_t *len);
 
-void uart_init_with_dma();
+char uart_get_char(struct stm_uart *uart);
 
-void uart_disable();
+int uart_check_rx_avail(struct stm_uart *uart);
 
-void uart_send_char(char c);
+void uart_tx_dma_complete_int_callback(struct stm_uart *uart);
 
-void uart_send_array(const char *data, uint32_t len);
+size_t uart_dma_tx_queue_avail(struct stm_uart *uart);
-
-void uart_send_string(const char *string);
-
-void uart_send_array_with_dma(const char *data, uint32_t len);
-
-void uart_send_string_with_dma(const char *string);
-
-int uart_receive_data_with_dma(const char **data, size_t *len);
 
+size_t uart_dma_rx_queue_avail(struct stm_uart *uart);
 
 #endif /* UART_UART_H_ */

stm-firmware/main.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -24,7 +24,9 @@
  */
 
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
+#include <inttypes.h>
 /* #include <arm_math.h> */
 #include <stm32/stm32f4xx.h>
 #include <cmsis/core_cm4.h>
@@ -33,12 +35,19 @@
 #include <reflow-controller/adc-meas.h>
 #include <reflow-controller/shell.h>
 #include <reflow-controller/digio.h>
-#include <reflow-controller/rotary-encoder.h>
+#include "fatfs/shimatta_sdio_driver/shimatta_sdio.h"
 #include <stm-periph/stm32-gpio-macros.h>
 #include <stm-periph/clock-enable-manager.h>
 #include <stm-periph/uart.h>
+#include <reflow-controller/shell-uart-config.h>
+#include <reflow-controller/oven-driver.h>
+#include <reflow-controller/safety-adc.h>
+#include <fatfs/ff.h>
+#include <reflow-controller/reflow-menu.h>
 
-static void setup_nvic_priorities()
+bool global_error_state;
+
+static void setup_nvic_priorities(void)
 {
 	/* No sub priorities */
 	NVIC_SetPriorityGrouping(2);
@@ -49,40 +58,221 @@ static void setup_nvic_priorities()
 	NVIC_SetPriority(DMA2_Stream7_IRQn, 3);
 }
 
-static float pt1000_value;
+FATFS fs;
-static volatile int pt1000_value_status;
+FATFS * const fs_ptr = &fs;
-static uint32_t rot;
 
-
+static inline void uart_gpio_config(void)
-int main()
 {
-	const char *uart_input;
+	/*
-	size_t uart_input_len;
+	 * In case the application is build in debug mode, use the TX/RX Pins on the debug header
-	shellmatta_handle_t shell_handle;
+	 * else the Pins on the DIGIO header are configured in the digio module
-	int uart_receive_status;
+	 */
 
+#ifdef DEBUGBUILD
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(SHELL_UART_PORT_RCC_MASK));
+	SHELL_UART_PORT->MODER &=  MODER_DELETE(SHELL_UART_TX_PIN) & MODER_DELETE(SHELL_UART_RX_PIN);
+	SHELL_UART_PORT->MODER |= ALTFUNC(SHELL_UART_RX_PIN) | ALTFUNC(SHELL_UART_TX_PIN);
+	SETAF(SHELL_UART_PORT, SHELL_UART_RX_PIN, SHELL_UART_RX_PIN_ALTFUNC);
+	SETAF(SHELL_UART_PORT, SHELL_UART_TX_PIN, SHELL_UART_TX_PIN_ALTFUNC);
+#endif
+}
+
+
+static char shell_uart_tx_buff[128];
+static char shell_uart_rx_buff[48];
+struct stm_uart shell_uart;
+
+static shellmatta_retCode_t write_shell_callback(const char *data, uint32_t len)
+{
+	uart_send_array_with_dma(&shell_uart, data, len);
+	return SHELLMATTA_OK;
+}
+
+static inline void setup_shell_uart(struct stm_uart *uart)
+{
+	uart->rx = 1;
+	uart->tx = 1;
+	uart->brr_val = SHELL_UART_BRR_REG_VALUE;
+	uart->rcc_reg = &SHELL_UART_RCC_REG;
+	uart->rcc_bit_no = BITMASK_TO_BITNO(SHELL_UART_RCC_MASK);
+	uart->uart_dev = SHELL_UART_PERIPH;
+	uart->dma_rx_buff = shell_uart_rx_buff;
+	uart->dma_tx_buff = shell_uart_tx_buff;
+	uart->rx_buff_count = sizeof(shell_uart_rx_buff);
+	uart->tx_buff_count = sizeof(shell_uart_tx_buff);
+	uart->base_dma_num = 2;
+	uart->dma_rx_stream = SHELL_UART_RECEIVE_DMA_STREAM;
+	uart->dma_tx_stream = SHELL_UART_SEND_DMA_STREAM;
+	uart->dma_rx_trigger_channel = SHELL_UART_RX_DMA_TRIGGER;
+	uart->dma_tx_trigger_channel = SHELL_UART_TX_DMA_TRIGGER;
+
+	uart_init(uart);
+	NVIC_EnableIRQ(DMA2_Stream7_IRQn);
+}
+
+static bool mount_sd_card_if_avail(bool mounted)
+{
+	FRESULT res;
+
+	if (sdio_check_inserted() && mounted) {
+		memset(fs_ptr, 0, sizeof(FATFS));
+		return false;
+	}
+
+	if (!sdio_check_inserted() && !mounted) {
+		res = f_mount(fs_ptr, "0:/", 1);
+		if (res == FR_OK)
+			return true;
+		else
+			return false;
+	}
+
+	return mounted;
+}
+
+static void setup_unused_pins(void)
+{
+	int i;
+
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(RCC_AHB1ENR_GPIOEEN));
+	GPIOE->MODER = 0UL;
+	for (i = 0; i < 16; i++)
+		GPIOE->PUPDR |= PULLDOWN(i);
+}
+
+static inline void setup_system(void)
+{
 	setup_nvic_priorities();
 	systick_setup();
 
 	adc_pt1000_setup_meas();
-
+	oven_driver_init();
 	digio_setup_default_all();
 	led_setup();
 	loudspeaker_setup();
-	rotary_encoder_setup();
+	reflow_menu_init();
+	safety_adc_init();
 
-	uart_init_with_dma();
+	uart_gpio_config();
-
+	setup_shell_uart(&shell_uart);
-	shell_handle = shell_init();
-
-	while(1) {
-		pt1000_value_status = adc_pt1000_get_current_resistance(&pt1000_value);
-		rot = rotary_encoder_get_abs_val();
-		uart_receive_status = uart_receive_data_with_dma(&uart_input, &uart_input_len);
-		if (uart_receive_status >= 1)
-			shell_handle_input(shell_handle, uart_input, uart_input_len);
-	}
 
+	setup_unused_pins();
 }
 
+static void handle_shell_uart_input(shellmatta_handle_t shell_handle)
+{
+	int uart_receive_status;
+	const char *uart_input;
+	size_t uart_input_len;
 
+	/* Handle UART input for shell */
+	uart_receive_status = uart_receive_data_with_dma(&shell_uart, &uart_input, &uart_input_len);
+	if (uart_receive_status >= 0)
+		shell_handle_input(shell_handle, uart_input, uart_input_len);
+}
+
+static void zero_ccm_ram(void)
+{
+	/* These extern variables are placed in the linker script */
+	extern char _sccmram;
+	extern char _eccmram;
+	uint32_t len;
+	uint32_t i;
+	uint32_t *ptr = (uint32_t *)&_sccmram;
+
+	len = (uint32_t)&_eccmram - (uint32_t)&_sccmram;
+	for (i = 0; i < len; i++)
+		ptr[i] = 0UL;
+}
+
+/**
+ * @brief This function sets the appropriate error flags in the oven PID controller
+ * depending on the Safety ADC measurements.
+ * The PID controller's error flags have to be cleared via the GUI by either starting a new RUN or explicitly
+ * ack'ing these errors.
+ */
+static void propagate_safety_adc_error_to_oven_pid(void)
+{
+	enum safety_adc_check_result safety_adc_result;
+
+	safety_adc_result = safety_adc_get_errors();
+
+	if (safety_adc_result & SAFETY_ADC_CHECK_TEMP_LOW ||
+	    safety_adc_result & SAFETY_ADC_CHECK_TEMP_HIGH)
+		oven_pid_report_error(OVEN_PID_ERR_OVERTEMP);
+
+	if (safety_adc_result & SAFETY_ADC_CHECK_VREF_LOW ||
+	    safety_adc_result & SAFETY_ADC_CHECK_VREF_HIGH)
+		oven_pid_report_error(OVEN_PID_ERR_VREF_TOL);
+
+	if (safety_adc_result & SAFETY_ADC_INTERNAL_ERROR)
+		oven_pid_report_error(0);
+}
+
+int main(void)
+{
+	bool sd_card_mounted = false;
+	shellmatta_handle_t shell_handle;
+	int menu_wait_request;
+	uint64_t quarter_sec_timestamp = 0ULL;
+	const struct oven_pid_status *pid_status;
+	enum adc_pt1000_error pt1000_status;
+
+	zero_ccm_ram();
+	setup_system();
+
+	global_error_state = false;
+
+	shell_handle = shell_init(write_shell_callback);
+	shell_print_motd(shell_handle);
+
+	while (1) {
+		sd_card_mounted = mount_sd_card_if_avail(sd_card_mounted);
+
+		pid_status = oven_pid_get_status();
+
+		if (systick_ticks_have_passed(quarter_sec_timestamp, 250)) {
+			quarter_sec_timestamp = systick_get_global_tick();
+
+			(void)handle_safety_adc();
+			propagate_safety_adc_error_to_oven_pid();
+
+			if (global_error_state)
+				led_set(0, !led_get(0));
+			else
+				led_set(0, 0);
+		}
+
+		pt1000_status = adc_pt1000_check_error();
+		global_error_state = pid_status->error_set || !!safety_adc_get_errors() || !!pt1000_status;
+
+		menu_wait_request = reflow_menu_handle();
+
+		/* Deactivate oven output in case of error! */
+		if (!pid_status->active || global_error_state)
+			oven_driver_set_power(0U);
+
+		handle_shell_uart_input(shell_handle);
+
+		if (menu_wait_request)
+			__WFI();
+
+	}
+
+	return 0;
+}
+
+void sdio_wait_ms(uint32_t ms)
+{
+	systick_wait_ms(ms);
+}
+
+void DMA2_Stream7_IRQHandler(void)
+{
+	uint32_t hisr = DMA2->HISR;
+
+	DMA2->HIFCR = hisr;
+
+	if (hisr & DMA_HISR_TCIF7)
+		uart_tx_dma_complete_int_callback(&shell_uart);
+}

stm-firmware/oven-driver.c

@@ -0,0 +1,163 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/oven-driver.h>
+#include <reflow-controller/periph-config/oven-driver-hwcfg.h>
+#include <stm-periph/clock-enable-manager.h>
+#include <reflow-controller/systick.h>
+#include <reflow-controller/adc-meas.h>
+#include <reflow-controller/temp-converter.h>
+
+static struct pid_controller oven_pid;
+
+static struct oven_pid_status oven_pid_current_status = {
+	.active = false,
+	.error_set = false,
+	.target_temp = 0.0f,
+	.current_temp = 0.0f,
+	.timestamp_last_run = 0ULL
+};
+
+void oven_driver_init()
+{
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(OVEN_CONTROLLER_PORT_RCC_MASK));
+	rcc_manager_enable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(OVEN_CONTROLLER_TIM_RCC_MASK));
+
+	OVEN_CONTROLLER_PORT->MODER &= MODER_DELETE(OVEN_CONTROLLER_PIN);
+	OVEN_CONTROLLER_PORT->MODER |= ALTFUNC(OVEN_CONTROLLER_PIN);
+	SETAF(OVEN_CONTROLLER_PORT, OVEN_CONTROLLER_PIN, OVEN_CONTROLLER_PIN_ALTFUNC);
+
+	OVEN_CONTROLLER_PWM_TIMER->CR2 = 0UL;
+
+	OVEN_CONTROLLER_PWM_TIMER->CCMR2 = TIM_CCMR2_OC3M;
+	OVEN_CONTROLLER_PWM_TIMER->CCER = TIM_CCER_CC3E | TIM_CCER_CC3P;
+
+	OVEN_CONTROLLER_PWM_TIMER->ARR = 1000U;
+	OVEN_CONTROLLER_PWM_TIMER->PSC = 42000U - 1U;
+
+	OVEN_CONTROLLER_PWM_TIMER->CR1 = TIM_CR1_CMS | TIM_CR1_CEN;
+}
+
+void oven_driver_set_power(uint8_t power)
+{
+	if (power > 100U)
+		power = 100U;
+
+	OVEN_CONTROLLER_PWM_TIMER->CCR3 = power * 10;
+}
+
+void oven_driver_disable()
+{
+	OVEN_CONTROLLER_PWM_TIMER->CR1 = 0UL;
+	OVEN_CONTROLLER_PWM_TIMER->CR2 = 0UL;
+	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(OVEN_CONTROLLER_PORT_RCC_MASK));
+	rcc_manager_disable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(OVEN_CONTROLLER_TIM_RCC_MASK));
+}
+
+void oven_pid_ack_errors(void)
+{
+	oven_pid_current_status.error_set = false;
+	oven_pid_current_status.error_flags.vref_tol = false;
+	oven_pid_current_status.error_flags.pt1000_other = false;
+	oven_pid_current_status.error_flags.generic_error = false;
+	oven_pid_current_status.error_flags.pt1000_adc_off = false;
+	oven_pid_current_status.error_flags.controller_overtemp = false;
+	oven_pid_current_status.error_flags.pt1000_adc_watchdog = false;
+}
+
+void oven_pid_init(struct pid_controller *controller_to_copy)
+{
+	pid_copy(&oven_pid, controller_to_copy);
+	oven_pid.output_sat_min = 0.0f;
+	oven_pid.output_sat_max = 100.0f;
+	oven_pid_current_status.timestamp_last_run = 0ULL;
+	oven_pid_current_status.active = true;
+	oven_pid_ack_errors();
+}
+
+void oven_pid_handle(float target_temp)
+{
+	float pid_out;
+	float current_temp;
+	int resistance_status;
+	enum adc_pt1000_error pt1000_error;
+
+	if (oven_pid_current_status.active && !oven_pid_current_status.error_set) {
+		if (systick_ticks_have_passed(oven_pid_current_status.timestamp_last_run,
+					      (uint64_t)(oven_pid.sample_period * 1000))) {
+
+			resistance_status = adc_pt1000_get_current_resistance(&current_temp);
+			if (resistance_status < 0) {
+				oven_driver_set_power(0);
+				pt1000_error = adc_pt1000_check_error();
+				if (pt1000_error & ADC_PT1000_WATCHDOG_ERROR)
+					oven_pid_report_error(OVEN_PID_ERR_PT1000_ADC_WATCHDOG);
+				if (pt1000_error & ADC_PT1000_INACTIVE)
+					oven_pid_report_error(OVEN_PID_ERR_PT1000_ADC_OFF);
+				if (pt1000_error & ADC_PT1000_OVERFLOW)
+					oven_pid_report_error(OVEN_PID_ERR_PT1000_OTHER);
+
+				return;
+			}
+
+			(void)temp_converter_convert_resistance_to_temp(current_temp, &current_temp);
+
+			pid_out = pid_sample(&oven_pid, target_temp - current_temp);
+			oven_driver_set_power((uint8_t)pid_out);
+			oven_pid_current_status.timestamp_last_run = systick_get_global_tick();
+			oven_pid_current_status.target_temp = target_temp;
+			oven_pid_current_status.current_temp = current_temp;
+		}
+	}
+}
+
+void oven_pid_report_error(enum oven_pid_error_report report)
+{
+	struct oven_pid_errors *e = &oven_pid_current_status.error_flags;
+
+	oven_pid_current_status.active = false;
+	oven_pid_current_status.error_set = true;
+
+	if (report == 0) {
+		e->generic_error = true;
+	}
+	if (report & OVEN_PID_ERR_OVERTEMP)
+		e->controller_overtemp = true;
+	if (report & OVEN_PID_ERR_VREF_TOL)
+		e->controller_overtemp = true;
+	if (report & OVEN_PID_ERR_PT1000_OTHER)
+		e->pt1000_other = true;
+	if (report & OVEN_PID_ERR_PT1000_ADC_OFF)
+		e->pt1000_adc_off = true;
+	if (report & OVEN_PID_ERR_PT1000_ADC_WATCHDOG)
+		e->pt1000_adc_watchdog = true;
+}
+
+const struct oven_pid_status *oven_pid_get_status()
+{
+	return &oven_pid_current_status;
+}
+
+void oven_pid_stop()
+{
+	oven_pid_current_status.active = false;
+	oven_pid_current_status.target_temp = 0.0f;
+	oven_pid_current_status.current_temp = 0.0f;
+}

stm-firmware/pid-controller.c

@@ -0,0 +1,109 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/pid-controller.h>
+#include <string.h>
+
+void pid_init(struct pid_controller *pid, float k_deriv, float k_int, float k_p, float output_sat_min, float output_sat_max, float integral_max, float sample_period)
+{
+	if (!pid)
+		return;
+
+	pid->sample_period = sample_period;
+	pid->k_p = k_p;
+	pid->k_int = k_int;
+	pid->k_deriv = k_deriv;
+	pid->k_int_t = pid->k_int * pid->sample_period * 0.5f;
+	pid->k_deriv_t = pid->k_deriv * 2.0f / pid->sample_period;
+	pid->output_sat_max = output_sat_max;
+	pid->output_sat_min = output_sat_min;
+	pid->integral_max = integral_max;
+
+	pid_zero(pid);
+}
+
+int pid_copy(struct pid_controller *dest, const struct pid_controller *src)
+{
+	if (!dest || !src)
+		return -1;
+
+	memcpy(dest, src, sizeof(struct pid_controller));
+
+	return 0;
+}
+
+void pid_zero(struct pid_controller *pid)
+{
+	pid->control_output = 0.0f;
+	pid->last_in = 0.0f;
+	pid->integral = 0.0f;
+}
+
+static void calculate_integral(struct pid_controller *pid, float deviation)
+{
+	pid->integral = pid->integral + pid->k_int_t * (deviation + pid->last_in);
+
+	/* Saturate integral term to spoecified maximum */
+	if (pid->integral > pid->integral_max) {
+		pid->integral = pid->integral_max;
+	} else if (pid->integral < -pid->integral_max){
+		pid->integral = - pid->integral_max;
+	}
+}
+
+float pid_sample(struct pid_controller *pid, float deviation)
+{
+	float output;
+
+	if (!pid)
+		return 0.0;
+
+	output = deviation * pid->k_p;
+
+	if (!(deviation > 0.0f && pid->control_output > pid->output_sat_max - 0.5) &&
+	    !(deviation < 0.0f && pid->control_output < pid->output_sat_min + 0.5)) {
+		calculate_integral(pid, deviation);
+	}
+
+	/* Calculate derivative part */
+	pid->derivate = pid->k_deriv_t * (deviation - pid->last_in) - pid->derivate;
+
+	output += pid->derivate;
+	output += pid->integral;
+
+	/* Saturate output */
+	if (output < pid->output_sat_min)
+		output = pid->output_sat_min;
+	else if (output > pid->output_sat_max)
+		output = pid->output_sat_max;
+
+	pid->control_output = output;
+	pid->last_in = deviation;
+
+	return output;
+}
+
+float pid_get_control_output(const struct pid_controller *pid)
+{
+	if (!pid)
+		return 0.0f;
+
+	return pid->control_output;
+}

stm-firmware/program-device.sh

@@ -1,5 +1,10 @@
 #!/bin/bash
 
+if [[ -z $1 ]]; then
+	echo "Usage: $0 <ELF-file>"
+	exit -1
+fi
+
 JLinkGDBServer -if SWD -device STM32F407VE &
 sleep 2
 
@@ -12,7 +17,7 @@ if [[ $gdbpid == "" ]]; then
 	exit
 fi
 
-arm-none-eabi-gdb -x program-device.gdb reflow-controller.elf
+arm-none-eabi-gdb -x program-device.gdb $1
 sleep 2
 
 kill $gdbpid

stm-firmware/reflow-menu.c

@@ -0,0 +1,285 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/reflow-menu.h>
+#include <reflow-controller/ui/menu.h>
+#include <reflow-controller/ui/lcd.h>
+#include <reflow-controller/rotary-encoder.h>
+#include <reflow-controller/systick.h>
+#include <reflow-controller/adc-meas.h>
+#include <reflow-controller/safety-adc.h>
+#include <reflow-controller/temp-converter.h>
+#include <helper-macros/helper-macros.h>
+#include <stm-periph/unique-id.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+
+static char __attribute__((section(".ccmram"))) display_buffer[4][21] = {0};
+static struct lcd_menu reflow_menu;
+static struct lcd_menu * const reflow_menu_ptr = &reflow_menu;
+
+static void update_display_buffer(uint8_t row, const char *data)
+{
+	int i;
+
+	if (row > 4)
+		return;
+	if (!data)
+		return;
+
+	for (i = 0; data[i] && i < LCD_CHAR_WIDTH; i++) {
+		display_buffer[row][i] = data[i];
+	}
+
+	display_buffer[row][i] = 0;
+}
+
+static void reflow_menu_monitor(struct lcd_menu *menu, enum menu_entry_func_entry entry_type, void *parent)
+{
+	static void *my_parent;
+	static uint64_t my_timestamp = 0;
+	char line[17];
+	float tmp;
+	int res;
+	const char *prefix;
+
+	if (entry_type == MENU_ENTRY_FIRST_ENTER) {
+		my_parent = parent;
+		menu_display_clear(menu);
+	}
+
+	if (systick_ticks_have_passed(my_timestamp, 250)) {
+		my_timestamp = systick_get_global_tick();
+		adc_pt1000_get_current_resistance(&tmp);
+		snprintf(line, sizeof(line), "Res: %.1f", tmp);
+		menu->update_display(0, line);
+
+		res = temp_converter_convert_resistance_to_temp(tmp, &tmp);
+		switch (res) {
+		case -1:
+			prefix = "<";
+			break;
+		case 1:
+			prefix = ">";
+			break;
+		default:
+			prefix = "";
+			break;
+		}
+
+		snprintf(line, sizeof(line), "Temp: %s%.1f " LCD_DEGREE_SYMBOL_STRING "C", prefix, tmp);
+		menu->update_display(1, line);
+
+		tmp = safety_adc_get_temp();
+		snprintf(line, sizeof(line), "Tj: %.1f " LCD_DEGREE_SYMBOL_STRING "C", tmp);
+		menu->update_display(2, line);
+
+		tmp = safety_adc_get_vref();
+		snprintf(line, sizeof(line), "Vref: %.1f mV", tmp);
+		menu->update_display(3, line);
+	}
+
+	if (menu->inputs.push_button == BUTTON_SHORT_RELEASED || menu->inputs.push_button == BUTTON_LONG) {
+		menu_entry_dropback(menu, my_parent);
+	}
+}
+
+static void reflow_menu_about(struct lcd_menu *menu, enum menu_entry_func_entry entry_type, void *parent)
+{
+	static void *my_parent;
+	static bool button_ready;
+	static int page = 0;
+	static uint32_t uptime_secs;
+	uint32_t new_uptime_secs;
+	uint32_t uptime_mins;
+	uint32_t uptime_hours;
+	uint32_t uptime_days;
+	int16_t rot_delta;
+	uint32_t ser1, ser2, ser3;
+	enum button_state push_button;
+
+	if (entry_type == MENU_ENTRY_FIRST_ENTER) {
+		uptime_secs = 0ULL;
+		page = 0;
+		my_parent = parent;
+		button_ready = false;
+		menu_display_clear(menu);
+		menu_ack_rotary_delta(menu);
+	}
+
+	rot_delta = menu_get_rotary_delta(menu);
+	if (rot_delta >= 4) {
+		menu_ack_rotary_delta(menu);
+		if (page < 4) {
+			page++;
+			menu_display_clear(menu);
+		}
+	} else if (rot_delta <= -4) {
+		menu_ack_rotary_delta(menu);
+		if (page > 0) {
+			page--;
+			menu_display_clear(menu);
+		}
+	}
+
+	switch (page) {
+	case 0:
+		menu_lcd_output(menu, 0, LCD_SHIMATTA_STRING "    Shimatta");
+		menu_lcd_output(menu, 1, "Oven Controller");
+		menu_lcd_output(menu, 2, "(c) Mario H\xF5ttel");
+		menu_lcd_output(menu, 3, "Page 1/5");
+		break;
+	case 1:
+		menu_lcd_output(menu, 0, "Version Number:");
+		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]");
+#else
+		menu_lcd_output(menu, 3, "Page 2/5");
+#endif
+		break;
+	case 2:
+		menu_lcd_output(menu, 0, "Compile Info");
+		menu_lcd_output(menu, 1, __DATE__);
+		menu_lcd_output(menu, 2, __TIME__);
+		menu_lcd_output(menu, 3, "Page 3/5");
+		break;
+	case 3:
+		unique_id_get(&ser1, &ser2, &ser3);
+
+		menu_lcd_outputf(menu, 0, "Serial: %08X", ser1);
+		menu_lcd_outputf(menu, 1, "        %08X", ser2);
+		menu_lcd_outputf(menu, 2, "        %08X", ser3);
+		menu_lcd_output(menu, 3, "Page 4/5");
+		break;
+	case 4:
+		systick_get_uptime_from_tick(&uptime_days, &uptime_hours, &uptime_mins, &new_uptime_secs);
+		if (new_uptime_secs != uptime_secs) {
+			uptime_secs = new_uptime_secs;
+			menu_lcd_output(menu, 0, "Uptime:");
+			menu_lcd_outputf(menu, 1, "%lu day%s %02lu:%02lu:%02lu",
+				 uptime_days, (uptime_days == 1 ? "" : "s"), uptime_hours, uptime_mins, uptime_secs);
+			menu_lcd_output(menu, 3, "Page 5/5");
+		}
+		break;
+	default:
+		page = 0;
+		break;
+	}
+
+	push_button = menu_get_button_state(menu);
+
+	if (push_button == BUTTON_IDLE)
+		button_ready = true;
+
+	if (button_ready &&
+		(push_button == BUTTON_SHORT_RELEASED || push_button == BUTTON_LONG)) {
+		menu_entry_dropback(menu, my_parent);
+	}
+}
+
+static void reflow_menu_root_entry(struct lcd_menu *menu, enum menu_entry_func_entry entry_type, void *parent)
+{
+	(void)parent;
+	static struct menu_list list;
+	static bool button_valid;
+	static const char * const root_entry_names[] = {
+		"About",
+		"Monitoring",
+		NULL
+	};
+	static const menu_func_t root_entry_funcs[] = {
+		reflow_menu_about,
+		reflow_menu_monitor
+	};
+	enum button_state push_button;
+	int16_t rot_delta;
+
+	if (entry_type != MENU_ENTRY_CONTINUE) {
+		menu_display_clear(menu);
+		update_display_buffer(0, "Main Menu");
+		menu_ack_rotary_delta(menu);
+		if (entry_type == MENU_ENTRY_FIRST_ENTER) {
+			button_valid = false;
+			list.entry_names = root_entry_names;
+			list.submenu_list = root_entry_funcs;
+			list.update_display = menu->update_display;
+			list.currently_selected = 0;
+			menu_list_compute_count(&list);
+		}
+	}
+
+	push_button = menu_get_button_state(menu);
+	rot_delta = menu_get_rotary_delta(menu);
+
+	if (push_button == BUTTON_IDLE) {
+		button_valid = true;
+	} else if (button_valid && push_button == BUTTON_SHORT_RELEASED) {
+		/* Enter currently selected menu_entry */
+		menu_list_enter_selected_entry(&list, menu);
+	}
+
+	if (rot_delta >= 4) {
+		menu_list_scroll_down(&list);
+		menu_ack_rotary_delta(menu);
+	} else if (rot_delta <= -4) {
+		menu_list_scroll_up(&list);
+		menu_ack_rotary_delta(menu);
+	}
+
+	menu_list_display(&list, 1, 3);
+}
+
+int reflow_menu_handle()
+{
+	int32_t rot_delta;
+	enum button_state button;
+	static enum lcd_fsm_ret lcd_ret = LCD_FSM_NOP;
+
+	rot_delta = rotary_encoder_get_change_val();
+	button = button_read_event();
+
+	menu_handle(reflow_menu_ptr, (int16_t)rot_delta, button);
+
+	if (lcd_ret == LCD_FSM_CALL_AGAIN || lcd_tick_100us >= 5) {
+		lcd_ret = lcd_fsm_write_buffer(display_buffer);
+		lcd_tick_100us = 0UL;
+	}
+
+	if (lcd_ret == LCD_FSM_CALL_AGAIN)
+		return 0;
+	else
+		return 1;
+}
+
+void reflow_menu_init()
+{
+	rotary_encoder_setup();
+	button_init();
+	lcd_init();
+
+	menu_init(reflow_menu_ptr, reflow_menu_root_entry, update_display_buffer);
+}

stm-firmware/rotary-encoder.c

@@ -8,7 +8,7 @@
 * 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,
+* 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.
@@ -83,3 +83,8 @@ void rotary_encoder_stop(void)
 	rcc_manager_disable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(ROTARY_ENCODER_TIMER_RCC_MASK));
 	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(ROTARY_ENCODER_RCC_MASK));
 }
+
+void rotary_encoder_zero(void)
+{
+	ROTARY_ENCODER_TIMER->CNT = 0UL;
+}

stm-firmware/safety-adc.c

@@ -0,0 +1,188 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/safety-adc.h>
+#include <reflow-controller/periph-config/safety-adc-hwcfg.h>
+#include <helper-macros/helper-macros.h>
+#include <stm-periph/clock-enable-manager.h>
+
+enum safety_adc_check_result global_safety_adc_status;
+
+enum safety_adc_check_result safety_adc_get_errors()
+{
+	return global_safety_adc_status;
+}
+
+void safety_adc_clear_errors(void)
+{
+	global_safety_adc_status = SAFETY_ADC_CHECK_OK;
+}
+
+void safety_adc_init()
+{
+	rcc_manager_enable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(SAFETY_ADC_ADC_RCC_MASK));
+
+	safety_adc_clear_errors();
+
+	/* Enable temperature and VREFINT measurement */
+	ADC->CCR |= ADC_CCR_TSVREFE;
+
+	/* Set sample time for channels 16 and 17 */
+	SAFETY_ADC_ADC_PERIPHERAL->SMPR1 |= ADC_SMPR1_SMP17 | ADC_SMPR1_SMP16;
+
+	/* Standard sequence. One measurement */
+	SAFETY_ADC_ADC_PERIPHERAL->SQR1 = 0UL;
+}
+
+
+void safety_adc_deinit()
+{
+	SAFETY_ADC_ADC_PERIPHERAL->CR1 = 0UL;
+	SAFETY_ADC_ADC_PERIPHERAL->CR2 = 0UL;
+	SAFETY_ADC_ADC_PERIPHERAL->SMPR1  = 0UL;
+	rcc_manager_enable_clock(&RCC->APB1ENR, BITMASK_TO_BITNO(RCC_APB2ENR_ADC2EN));
+}
+
+enum safety_adc_check_result safety_adc_check_results(uint16_t vref_result, uint16_t temp_result,
+						      float *vref_calculated, float *temp_calculated)
+{
+	enum safety_adc_check_result res = SAFETY_ADC_CHECK_OK;
+	float vref;
+	float temp;
+
+
+	vref = (SAFETY_ADC_INT_REF_MV * 4095.0f) / (float)vref_result;
+	if (vref_calculated) {
+		*vref_calculated = vref;
+	}
+
+	temp = (((float)temp_result / 4095.0f * 2500.0f -
+			     SAFETY_ADC_TEMP_NOM_MV) / SAFETY_ADC_TEMP_MV_SLOPE) + SAFETY_ADC_TEMP_NOM;
+	if (temp_calculated) {
+		*temp_calculated = temp;
+	}
+
+	if (ABS(vref - SAFETY_ADC_VREF_MVOLT) > SAFETY_ADC_VREF_TOL_MVOLT) {
+		if (vref > SAFETY_ADC_VREF_MVOLT)
+			res |= SAFETY_ADC_CHECK_VREF_HIGH;
+		else
+			res |= SAFETY_ADC_CHECK_VREF_LOW;
+	}
+
+	if (temp < SAFETY_ADC_TEMP_LOW_LIM)
+		res |= SAFETY_ADC_CHECK_TEMP_LOW;
+	else if (temp < SAFETY_ADC_CHECK_TEMP_HIGH)
+		res |= SAFETY_ADC_CHECK_TEMP_HIGH;
+
+	return res;
+}
+
+int safety_adc_poll_result(uint16_t *adc_result)
+{
+	int ret = 0;
+
+	if (!adc_result)
+		return -1000;
+
+	if (!(SAFETY_ADC_ADC_PERIPHERAL->CR2 & ADC_CR2_ADON)) {
+		return -1;
+	}
+
+	if (SAFETY_ADC_ADC_PERIPHERAL->SR & ADC_SR_EOC) {
+		*adc_result = (uint16_t)SAFETY_ADC_ADC_PERIPHERAL->DR;
+		SAFETY_ADC_ADC_PERIPHERAL->CR2 &= ~ADC_CR2_ADON;
+		ret = 1;
+	}
+
+	return ret;
+}
+
+void safety_adc_trigger_meas(enum safety_adc_meas_channel measurement)
+{
+	switch (measurement) {
+	case SAFETY_ADC_MEAS_TEMP:
+		SAFETY_ADC_ADC_PERIPHERAL->SQR3 = TEMP_CHANNEL_NUM;
+		break;
+	case SAFETY_ADC_MEAS_VREF:
+		SAFETY_ADC_ADC_PERIPHERAL->SQR3 = INT_REF_CHANNEL_NUM;
+		break;
+	default:
+		return;
+	}
+
+	SAFETY_ADC_ADC_PERIPHERAL->CR2 |= ADC_CR2_ADON;
+	SAFETY_ADC_ADC_PERIPHERAL->CR2 |= ADC_CR2_SWSTART;
+}
+
+static uint16_t safety_vref_meas_raw;
+static bool safety_vref_valid = false;
+static uint16_t safety_temp_meas_raw;
+static bool safety_temp_valid = false;
+static float safety_vref;
+static float safety_temp;
+
+enum safety_adc_check_result handle_safety_adc()
+{
+	static enum safety_adc_meas_channel safety_meas_channel = SAFETY_ADC_MEAS_VREF;
+	enum safety_adc_check_result check_result;
+	uint16_t result;
+	int poll_status;
+
+	poll_status = safety_adc_poll_result(&result);
+
+	if (poll_status < 0) {
+		safety_adc_trigger_meas(safety_meas_channel);
+	} else if (poll_status > 0) {
+		switch (safety_meas_channel) {
+		case SAFETY_ADC_MEAS_TEMP:
+			safety_temp_meas_raw = result;
+			safety_temp_valid = true;
+			safety_meas_channel = SAFETY_ADC_MEAS_VREF;
+			break;
+		case SAFETY_ADC_MEAS_VREF:
+			safety_vref_meas_raw = result;
+			safety_vref_valid = true;
+			safety_meas_channel = SAFETY_ADC_MEAS_TEMP;
+			break;
+		default:
+			safety_meas_channel = SAFETY_ADC_MEAS_VREF;
+			return SAFETY_ADC_INTERNAL_ERROR;
+		}
+	}
+
+	if (safety_temp_valid && safety_vref_valid) {
+		check_result = safety_adc_check_results(safety_vref_meas_raw, safety_temp_meas_raw, &safety_vref, &safety_temp);
+		global_safety_adc_status |= check_result;
+	} else {
+		check_result = SAFETY_ADC_CHECK_OK;
+	}
+
+	return check_result;
+}
+
+float safety_adc_get_temp()
+{
+	return safety_temp;
+}
+
+float safety_adc_get_vref()
+{
+	return safety_vref;
+}

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

@@ -0,0 +1,21 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/settings/settings-sd-card.h>

stm-firmware/settings/settings.c

@@ -0,0 +1,26 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/settings/settings.h>
+
+int settings_save_calibration()
+{
+	return 0;
+}

stm-firmware/shell.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -18,36 +18,37 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <stm32/stm32f4xx.h>
+#include <cmsis/core_cm4.h>
 #include <reflow-controller/shell.h>
 #include <stm-periph/uart.h>
 #include <string.h>
 #include <reflow-controller/adc-meas.h>
 #include <reflow-controller/digio.h>
 #include <stdlib.h>
+#include <malloc.h>
 #include <helper-macros/helper-macros.h>
 #include <reflow-controller/systick.h>
 #include <stm-periph/unique-id.h>
 #include <reflow-controller/calibration.h>
 #include <reflow-controller/temp-converter.h>
+#include <fatfs/ff.h>
+#include <reflow-controller/stack-check.h>
 #include <reflow-controller/rotary-encoder.h>
+#include <reflow-controller/safety-adc.h>
 
 #ifndef GIT_VER
 #define GIT_VER "VERSION NOT SET"
 #endif
 
+extern struct stm_uart shell_uart;
 static shellmatta_instance_t shell;
 static char shell_buffer[512];
-static char history_buffer[1024];
+static char history_buffer[600];
-
-static shellmatta_retCode_t write_shell_callback(const char *data, uint32_t len)
-{
-	uart_send_array_with_dma(data, len);
-	return SHELLMATTA_OK;
-}
 
 static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
-						    const char                  *arguments,
+					  const char                  *arguments,
-						    uint32_t                    length)
+					  uint32_t                    length)
 {
 	(void)arguments;
 	(void)length;
@@ -58,22 +59,22 @@ static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t   handle,
 	unique_id_get(&high_id, &mid_id, &low_id);
 
 	shellmatta_printf(handle, "Reflow Oven Controller Firmware " xstr(GIT_VER) "\r\n"
-				"Compiled: " __DATE__ " at " __TIME__ "\r\n"
+					"Compiled: " __DATE__ " at " __TIME__ "\r\n"
-				"Serial: %08X-%08X-%08X", high_id, mid_id, low_id);
+					"Serial: %08X-%08X-%08X", high_id, mid_id, low_id);
 
 	return SHELLMATTA_OK;
 }
 
 static shellmatta_retCode_t shell_cmd_digio_get(const shellmatta_handle_t   handle,
-						 const char                  *arguments,
+						const char                  *arguments,
-						 uint32_t                    length)
+						uint32_t                    length)
 {
 	(void)arguments;
 	(void)length;
 
 	shellmatta_printf(handle,
-				"DIGIO0 DIGIO1 DIGIO2 DIGIO3 LED0 LED1 LS\r\n"
+			  "DIGIO0 DIGIO1 DIGIO2 DIGIO3 LED0 LED1 LS\r\n"
-				"%d      %d      %d      %d      %d    %d    %d\r\n",
+			  "%d      %d      %d      %d      %d    %d    %d\r\n",
 			  digio_get(0), digio_get(1), digio_get(2), digio_get(3),
 			  led_get(0), led_get(1), loudspeaker_get());
 
@@ -81,8 +82,8 @@ static shellmatta_retCode_t shell_cmd_digio_get(const shellmatta_handle_t   hand
 }
 
 static shellmatta_retCode_t shell_cmd_digio_set(const shellmatta_handle_t   handle,
-						       const char                  *arguments,
+						const char                  *arguments,
-						       uint32_t                    length)
+						uint32_t                    length)
 {
 	(void)length;
 	(void)handle;
@@ -91,7 +92,8 @@ static shellmatta_retCode_t shell_cmd_digio_set(const shellmatta_handle_t   hand
 	char buff[64];
 	char *curr_token;
 
-	strncpy(buff, arguments, sizeof(buff));
+	strncpy(buff, arguments, sizeof(buff)-1);
+	buff[63] = '\0';
 
 	curr_token = strtok(buff, " ");
 	curr_token = strtok(NULL, " ");
@@ -187,37 +189,195 @@ static shellmatta_retCode_t shell_cmd_uptime(const shellmatta_handle_t   handle,
 {
 	(void)arguments;
 	(void)length;
+	uint32_t days;
+	uint32_t hours;
+	uint32_t mins;
+	uint32_t secs;
 
-	shellmatta_printf(handle, "Uptime: %llu secs", global_tick_ms/1000);
+	systick_get_uptime_from_tick(&days, &hours, &mins, &secs);
+
+	shellmatta_printf(handle, "Uptime: %u day%s %02u:%02u:%02u",
+					days, (days == 1 ? "" : "s"),
+					hours,
+					mins,
+					secs);
 	return SHELLMATTA_OK;
 }
 
 static shellmatta_retCode_t shell_cmd_cal(const shellmatta_handle_t   handle,
-						  const char                  *arguments,
+					  const char                  *arguments,
-						  uint32_t length)
+					  uint32_t length)
 {
 	(void)arguments;
 	(void)length;
 
-	calibration_sequence_shell_cmd(handle);
+	return calibration_sequence_shell_cmd(handle, arguments, length);
+}
+
+static shellmatta_retCode_t shell_meminfo(const shellmatta_handle_t   handle,
+					  const char                  *arguments,
+					  uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+	struct mallinfo mi;
+
+	shellmatta_printf(handle,
+			  "Stack pointer: %p\r\n"
+			  "Stack usage: 0x%x bytes\r\n"
+			  "Lim to heap: 0x%x bytes\r\n",
+			  read_stack_pointer(),
+			  stack_check_get_usage(),
+			  stack_check_get_free());
+
+	mi = mallinfo();
+	shellmatta_printf(handle, "\r\nDynamic Memory Management\r\n");
+	shellmatta_printf(handle, "Allocated bytes: %d\r\n", mi.arena, mi.arena);
+	shellmatta_printf(handle, "Number of free chunks: %d\r\n", mi.ordblks);
+	shellmatta_printf(handle, "Top-most, releasable space: %d\r\n", mi.keepcost);
+	shellmatta_printf(handle, "Total free space: %d\r\n", mi.fordblks);
+	shellmatta_printf(handle, "Total allocated space: %d\r\n", mi.uordblks);
+
 	return SHELLMATTA_OK;
 }
 
 static shellmatta_retCode_t shell_cmd_rot(const shellmatta_handle_t   handle,
-						  const char *arguments,
+					  const char *arguments,
-						  uint32_t length)
+					  uint32_t length)
 {
 	(void)arguments;
 	(void)length;
+
 	uint32_t rot_val;
-	int32_t delta;
 
 	rot_val = rotary_encoder_get_abs_val();
-	delta = rotary_encoder_get_change_val();
+	//delta = rotary_encoder_get_change_val();
-	shellmatta_printf(handle, "Rotary encoder value: %u, delta: %d\r\n", rot_val, delta);
+	shellmatta_printf(handle, "Rotary encoder value: %u\r\n", rot_val);
 
 	return SHELLMATTA_OK;
 }
+
+static shellmatta_retCode_t shell_cmd_pt1000_res_loop(const shellmatta_handle_t handle, const char *arguments,
+						      uint32_t length)
+{
+	(void)arguments;
+	(void)length;
+	static uint64_t timestamp = 0ULL;
+
+	if (systick_ticks_have_passed(timestamp, 150)) {
+		shell_cmd_pt1000_res(handle, "", 0UL);
+		timestamp = systick_get_global_tick();
+	}
+
+	return SHELLMATTA_CONTINUE;
+}
+
+static shellmatta_retCode_t shell_cmd_ls(const shellmatta_handle_t handle, const char *arguments,
+					 uint32_t length)
+{
+	(void)length;
+	(void)arguments;
+	DIR dir;
+	FRESULT res;
+	FILINFO fno;
+
+	res = f_opendir(&dir, "/");
+	if (res != FR_OK) {
+		shellmatta_printf(handle, "Filesystem inaccessible. Is an SD Card inserted?\r\n");
+		return SHELLMATTA_OK;
+	}
+
+	while (f_readdir(&dir, &fno) == FR_OK) {
+		if (fno.fname[0] == 0)
+			break;
+		shellmatta_printf(handle, "%c\t%s\r\n", (fno.fattrib & AM_DIR ? 'd' : 'f'), fno.fname);
+	}
+
+	f_closedir(&dir);
+
+	return SHELLMATTA_OK;
+}
+
+static shellmatta_retCode_t shell_cmd_reset(const shellmatta_handle_t handle, const char *arguments,
+					    uint32_t length)
+{
+	(void)handle;
+	(void)length;
+	(void)arguments;
+
+	NVIC_SystemReset();
+
+	return SHELLMATTA_BUSY;
+}
+
+static shellmatta_retCode_t shell_cmd_cat(const shellmatta_handle_t handle, const char *arguments,
+					  uint32_t length)
+{
+	FIL file;
+	char path_buff[256];
+	const char *path;
+	UINT bytes_read;
+	FRESULT res;
+
+	strncpy(path_buff, arguments, MIN(sizeof(path_buff), length));
+	path_buff[MIN(length, sizeof(path_buff)-1)] = 0;
+	path = strtok(path_buff, " ");
+	path = strtok(NULL, " ");
+
+	if (strlen(path) == 0) {
+		shellmatta_printf(handle, "Specify path!\r\n");
+		return SHELLMATTA_OK;
+	}
+
+	res = f_open(&file, path, FA_READ);
+	if (res == FR_OK) {
+		shellmatta_write(handle, "\r\n", 2U);
+		do {
+			res = f_read(&file, path_buff, sizeof(path_buff), &bytes_read);
+			if (bytes_read > 0)
+				shellmatta_write(handle, path_buff, bytes_read);
+			else
+				break;
+		} while (res == FR_OK);
+
+		shellmatta_write(handle, "\r\n", 2U);
+	}
+
+	if (res != FR_OK) {
+		shellmatta_printf(handle, "Error reading file\r\n");
+	}
+
+	f_close(&file);
+
+	return SHELLMATTA_OK;
+}
+
+static shellmatta_retCode_t shell_cmd_safety_adc(const shellmatta_handle_t handle, const char *arguments,
+					  uint32_t length)
+{
+	(void)length;
+	(void)arguments;
+
+	shellmatta_printf(handle, "VREF:\t%8.2f\tmV\r\n", safety_adc_get_vref());
+	shellmatta_printf(handle, "TEMP:\t%8.2f\tdeg. Celsius\r\n", safety_adc_get_temp());
+
+	shellmatta_printf(handle, "Errors:\t%X", safety_adc_get_errors());
+
+	return SHELLMATTA_OK;
+}
+
+static shellmatta_retCode_t shell_cmd_safety_adc_clear_error(const shellmatta_handle_t handle, const char *arguments,
+					  uint32_t length)
+{
+	(void)length;
+	(void)arguments;
+	(void)handle;
+
+	safety_adc_clear_errors();
+
+	return SHELLMATTA_OK;
+}
+
 //typedef struct shellmatta_cmd
 //{
 //    char                    *cmd;       /**< command name                           */
@@ -228,7 +388,7 @@ static shellmatta_retCode_t shell_cmd_rot(const shellmatta_handle_t   handle,
 //    struct shellmatta_cmd   *next;      /**< pointer to next command or NULL        */
 //} shellmatta_cmd_t;
 
-static shellmatta_cmd_t cmd[8] = {
+static shellmatta_cmd_t cmd[15] = {
 	{
 		.cmd = "version",
 		.cmdAlias = "ver",
@@ -245,13 +405,21 @@ static shellmatta_cmd_t cmd[8] = {
 		.cmdFct = shell_cmd_pt1000_res,
 		.next = &cmd[2],
 	},
+	{
+		.cmd = "pt1000-dump",
+		.cmdAlias = "ptdump",
+		.helpText = "Get current filtered and calibrated PT1000 resistance in a loop",
+		.usageText = "pt1000-dump",
+		.cmdFct = shell_cmd_pt1000_res_loop,
+		.next = &cmd[3],
+	},
 	{
 		.cmd = "pt1000-clear-error",
 		.cmdAlias = "pt-clear",
 		.helpText = "Clear error status of PT1000 reading",
 		.usageText = NULL,
 		.cmdFct = shell_cmd_clear_error_status,
-		.next = &cmd[3],
+		.next = &cmd[4],
 	},
 	{
 		.cmd = "digio-get",
@@ -259,7 +427,7 @@ static shellmatta_cmd_t cmd[8] = {
 		.helpText = "Read all digital input/output ports",
 		.usageText = NULL,
 		.cmdFct = shell_cmd_digio_get,
-		.next = &cmd[4],
+		.next = &cmd[5],
 	},
 	{
 		.cmd = "digio-set",
@@ -267,7 +435,7 @@ static shellmatta_cmd_t cmd[8] = {
 		.helpText = "Set DIGIO Port",
 		.usageText = "digio-set <num> <state>",
 		.cmdFct = shell_cmd_digio_set,
-		.next = &cmd[5],
+		.next = &cmd[6],
 	},
 	{
 		.cmd = "uptime",
@@ -275,7 +443,7 @@ static shellmatta_cmd_t cmd[8] = {
 		.helpText = "Get uptime in seconds",
 		.usageText = "",
 		.cmdFct = shell_cmd_uptime,
-		.next = &cmd[6],
+		.next = &cmd[7],
 	},
 	{
 		.cmd = "calibrate",
@@ -283,7 +451,15 @@ static shellmatta_cmd_t cmd[8] = {
 		.helpText = "Calibrate resistance measurement",
 		.usageText = "",
 		.cmdFct = shell_cmd_cal,
-		.next = &cmd[7],
+		.next = &cmd[8],
+	},
+	{
+		.cmd = "meminfo",
+		.cmdAlias = NULL,
+		.helpText = "Get information about memory usage",
+		.usageText = "",
+		.cmdFct = shell_meminfo,
+		.next = &cmd[9],
 	},
 	{
 		.cmd = "rotary-encoder",
@@ -291,30 +467,79 @@ static shellmatta_cmd_t cmd[8] = {
 		.helpText = "Get current rotary encoder value",
 		.usageText = "",
 		.cmdFct = shell_cmd_rot,
+		.next = &cmd[10],
+	},
+	{
+		.cmd = "ls",
+		.cmdAlias = NULL,
+		.helpText = "List filesystem contents",
+		.usageText = "",
+		.cmdFct = shell_cmd_ls,
+		.next = &cmd[11],
+	},
+	{
+		.cmd = "reset",
+		.cmdAlias = NULL,
+		.helpText = "Reset controller",
+		.usageText = "reset",
+		.cmdFct = shell_cmd_reset,
+		.next = &cmd[12],
+	},
+	{
+		.cmd = "cat",
+		.cmdAlias = NULL,
+		.helpText = "Print file contents",
+		.usageText = "cat <path>",
+		.cmdFct = shell_cmd_cat,
+		.next = &cmd[13],
+	},
+	{
+		.cmd = "safety-adc",
+		.cmdAlias = NULL,
+		.helpText = "",
+		.usageText = "",
+		.cmdFct = shell_cmd_safety_adc,
+		.next = &cmd[14],
+	},
+	{
+		.cmd = "safety-adc-clear-error",
+		.cmdAlias = NULL,
+		.helpText = "",
+		.usageText = "",
+		.cmdFct = shell_cmd_safety_adc_clear_error,
 		.next = NULL,
-	}
+	},
+
 };
 
-shellmatta_handle_t shell_init(void)
+shellmatta_handle_t shell_init(shellmatta_write_t write_func)
 {
 	shellmatta_handle_t handle;
 	shellmatta_retCode_t ret;
 
 	ret = shellmatta_doInit(&shell, &handle, shell_buffer, sizeof(shell_buffer), history_buffer, sizeof(history_buffer),
-			  "\e[1;32mEnter command:\e[m\r\n", cmd, write_shell_callback);
+				"\e[1;32mReflow Controller>\e[m ", cmd, write_func);
 	if (ret != SHELLMATTA_OK)
 		handle = NULL;
 
 	return handle;
 }
 
+void shell_print_motd(shellmatta_handle_t shell)
+{
+	/* Clear display and set cursor to home position */
+	shellmatta_printf(shell, "\e[2J\e[H");
+	shellmatta_printf(shell, "Shimatta 仕舞った Reflow Controller ready\r\n\r\n");
+	shell_cmd_ver(shell, NULL, 0UL);
+	shell_handle_input(shell, "\r\n", 2UL);
+}
 
 void shell_handle_input(shellmatta_handle_t shell, const char *data, size_t len)
 {
-	 if (!shell)
+	if (!shell)
-		 return;
+		return;
 
-	 shellmatta_processData(shell, (char *)data, (uint32_t)len);
+	shellmatta_processData(shell, (char *)data, (uint32_t)len);
 }
 
 void shell_print_string(shellmatta_handle_t shell, const char *string)

stm-firmware/stack-check.c

@@ -0,0 +1,47 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/stack-check.h>
+#include <stdint.h>
+
+extern char _estack;
+extern char heap_top;
+
+int32_t stack_check_get_usage()
+{
+	uint32_t stack_top;
+	uint32_t stack_ptr;
+
+	stack_ptr = read_stack_pointer();
+	stack_top = (uint32_t)&_estack;
+
+	return stack_top - stack_ptr;
+}
+
+int32_t stack_check_get_free()
+{
+	uint32_t upper_heap_boundary;
+	uint32_t stack_ptr;
+
+	stack_ptr = read_stack_pointer();
+	upper_heap_boundary = (uint32_t)&heap_top;
+
+	return stack_ptr - upper_heap_boundary;
+}

stm-firmware/stm-periph/clock-enable-manager.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.

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

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -33,6 +33,19 @@
 #include <stdbool.h>
 #include <string.h>
 
+static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_idx, size_t put_idx)
+{
+	size_t fill_level;
+
+	if (put_idx >= get_idx) {
+		fill_level = (put_idx - get_idx);
+	} else {
+		fill_level = buffer_size - get_idx + put_idx;
+	}
+
+	return fill_level;
+}
+
 static int dma_ring_buffer_switch_clock_enable(uint8_t base_dma, bool clk_en)
 {
 	int ret_val;
@@ -141,6 +154,19 @@ void dma_ring_buffer_periph_to_mem_stop(struct dma_ring_buffer_to_mem *buff)
 	memset(buff, 0, sizeof(struct dma_ring_buffer_to_mem));
 }
 
+int dma_ring_buffer_periph_to_mem_fill_level(struct dma_ring_buffer_to_mem *buff, size_t *fill_level)
+{
+	size_t put_idx;
+
+	if (!buff || !fill_level)
+		return -1000;
+
+	put_idx = buff->buffer_count - buff->dma->NDTR;
+	*fill_level = calculate_ring_buffer_fill_level(buff->buffer_count, buff->get_idx, put_idx);
+
+	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)
 {
 	if (!dma_buffer || !dma_stream || !data_buffer || !dest_reg)
@@ -163,19 +189,6 @@ int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *d
 	return 0;
 }
 
-static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_idx, size_t put_idx)
-{
-	size_t fill_level;
-
-	if (put_idx >= get_idx) {
-		fill_level = (put_idx - get_idx);
-	} else {
-		fill_level = buffer_size - get_idx + put_idx;
-	}
-
-	return fill_level;
-}
-
 static void queue_or_start_dma_transfer(struct dma_ring_buffer_to_periph *buff)
 {
 	uint32_t dma_transfer_cnt;
@@ -289,4 +302,14 @@ void dma_ring_buffer_mem_to_periph_stop(struct dma_ring_buffer_to_periph *buff)
 	memset(buff, 0, sizeof(struct dma_ring_buffer_to_periph));
 }
 
+int dma_ring_buffer_mem_to_periph_fill_level(struct dma_ring_buffer_to_periph *buff, size_t *fill_level)
+{
+	if (!buff || !fill_level)
+		return -1000;
+
+	*fill_level = calculate_ring_buffer_fill_level(buff->buffer_count, buff->dma_get_idx_current, buff->sw_put_idx);
+
+	return 0;
+}
+
 /** @} */

stm-firmware/stm-periph/uart.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -25,97 +25,192 @@
 #include <stm-periph/dma-ring-buffer.h>
 #include <string.h>
 
-static struct dma_ring_buffer_to_mem ring_buff_rx;
+int uart_init(struct stm_uart *uart)
-static struct dma_ring_buffer_to_periph ring_buff_tx;
-static char uart_rx_buffer[64];
-static char uart_tx_buffer[256];
-
-#ifdef DEBUGBUILD
-static inline void uart_gpio_config()
 {
-	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(UART_PORT_RCC_MASK));
+	int ret_val = 0;
-	UART_PORT->MODER &=  MODER_DELETE(UART_TX_PIN) & MODER_DELETE(UART_RX_PIN);
+	uint32_t cr3 = 0;
-	UART_PORT->MODER |= ALTFUNC(UART_RX_PIN) | ALTFUNC(UART_TX_PIN);
+	uint32_t cr1 = 0;
-	SETAF(UART_PORT, UART_RX_PIN, UART_RX_PIN_ALTFUNC);
-	SETAF(UART_PORT, UART_TX_PIN, UART_TX_PIN_ALTFUNC);
-}
-#endif
 
-void uart_init_with_dma()
+	if (!uart)
-{
+		return -1000;
-	rcc_manager_enable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(UART_RCC_MASK));
-#ifdef DEBUGBUILD
-	uart_gpio_config();
-#endif
-	UART_PERIPH->BRR = UART_BRR_REG_VALUE;
-	UART_PERIPH->CR3 = USART_CR3_DMAR | USART_CR3_DMAT;
-	UART_PERIPH->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
 
-	dma_ring_buffer_periph_to_mem_initialize(&ring_buff_rx, 2, UART_RECEIVE_DMA_STREAM, sizeof(uart_rx_buffer), 1U,
+	rcc_manager_enable_clock(uart->rcc_reg, uart->rcc_bit_no);
-						 uart_rx_buffer, (char *)&UART_PERIPH->DR, 4);
-	dma_ring_buffer_mem_to_periph_initialize(&ring_buff_tx, 2, UART_SEND_DMA_STREAM, sizeof(uart_tx_buffer), 1U,
-						 uart_tx_buffer, 4U, (void *)&UART_PERIPH->DR);
 
-	NVIC_EnableIRQ(DMA2_Stream7_IRQn);
+	/* Reset all config regs */
+	uart->uart_dev->CR1 = uart->uart_dev->CR2 = uart->uart_dev->CR3 = 0UL;
+
+	/* Set baud rate */
+	uart->uart_dev->BRR = uart->brr_val;
+
+	/* If DMA buffers are present, configure for DMA use */
+	if (uart->dma_rx_buff && uart->rx) {
+		cr3 |= USART_CR3_DMAR;
+
+		ret_val = dma_ring_buffer_periph_to_mem_initialize(&uart->rx_ring_buff,
+								uart->base_dma_num,
+								uart->dma_rx_stream,
+								uart->rx_buff_count,
+								1U,
+								uart->dma_rx_buff,
+								(char *)&uart->uart_dev->DR,
+								uart->dma_rx_trigger_channel);
+		if (ret_val)
+			return ret_val;
+	}
+
+	if (uart->dma_tx_buff && uart->tx) {
+		ret_val = dma_ring_buffer_mem_to_periph_initialize(&uart->tx_ring_buff,
+							 uart->base_dma_num,
+							 uart->dma_tx_stream,
+							 uart->tx_buff_count,
+							 1U,
+							 uart->dma_tx_buff,
+							 uart->dma_tx_trigger_channel,
+							 (void *)&uart->uart_dev->DR);
+		if (ret_val)
+			return ret_val;
+
+		cr3 |= USART_CR3_DMAT;
+	}
+	uart->uart_dev->CR3 = cr3;
+
+	if (uart->tx)
+		cr1 |= USART_CR1_TE;
+	if (uart->rx)
+		cr1 |= USART_CR1_RE;
+
+	/* Enable uart */
+	cr1 |= USART_CR1_UE;
+	uart->uart_dev->CR1 = cr1;
+
+	return 0;
 }
 
-void uart_disable()
+void uart_change_brr(struct stm_uart *uart, uint32_t brr)
 {
-	UART_PERIPH->CR1 = 0;
+	if (!uart || !uart->uart_dev)
-	UART_PERIPH->CR2 = 0;
+		return;
-	UART_PERIPH->CR3 = 0;
+
-	dma_ring_buffer_periph_to_mem_stop(&ring_buff_rx);
+	uart->brr_val = brr;
-	dma_ring_buffer_mem_to_periph_stop(&ring_buff_tx);
+	uart->uart_dev->BRR = brr;
-	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(UART_PORT_RCC_MASK));
-	rcc_manager_disable_clock(&RCC->APB2ENR, BITMASK_TO_BITNO(UART_RCC_MASK));
 }
 
-void uart_send_char(char c)
+void uart_disable(struct stm_uart *uart)
 {
-	while(!(UART_PERIPH->SR & USART_SR_TXE));
+	if (!uart)
-	UART_PERIPH->DR = c;
+		return;
+
+	uart->uart_dev->CR1 = 0;
+	uart->uart_dev->CR2 = 0;
+	uart->uart_dev->CR3 = 0;
+
+	if (uart->rx && uart->dma_rx_buff)
+		dma_ring_buffer_periph_to_mem_stop(&uart->rx_ring_buff);
+
+	if (uart->dma_tx_buff && uart->tx)
+		dma_ring_buffer_mem_to_periph_stop(&uart->tx_ring_buff);
+
+	rcc_manager_disable_clock(uart->rcc_reg, uart->rcc_bit_no);
 }
 
-void uart_send_array(const char *data, uint32_t len)
+void uart_send_char(struct stm_uart *uart, char c)
+{
+	if (!uart || !uart->uart_dev)
+		return;
+
+	while(!(uart->uart_dev->SR & USART_SR_TXE));
+	uart->uart_dev->DR = c;
+}
+
+void uart_send_array(struct stm_uart *uart, const char *data, uint32_t len)
 {
 	uint32_t i;
 
 	for (i = 0; i < len; i++)
-		uart_send_char(data[i]);
+		uart_send_char(uart, data[i]);
 }
 
-void uart_send_string(const char *string)
+void uart_send_string(struct stm_uart *uart, const char *string)
 {
 	int i;
 
 	for (i = 0; string[i] != '\0'; i++)
-		uart_send_char(string[i]);
+		uart_send_char(uart, string[i]);
 }
 
-void uart_send_array_with_dma(const char *data, uint32_t len)
+void uart_send_array_with_dma(struct stm_uart *uart, const char *data, uint32_t len)
 {
-	dma_ring_buffer_mem_to_periph_insert_data(&ring_buff_tx, data, len);
+	if (!uart || !uart->dma_tx_buff)
+		return;
+
+	dma_ring_buffer_mem_to_periph_insert_data(&uart->tx_ring_buff, data, len);
 }
 
-void uart_send_string_with_dma(const char *string)
+void uart_send_string_with_dma(struct stm_uart *uart, const char *string)
 {
 	size_t len;
 
 	len = strlen(string);
-	uart_send_array_with_dma(string, (uint32_t)len);
+	uart_send_array_with_dma(uart, string, (uint32_t)len);
 }
 
-int uart_receive_data_with_dma(const char **data, size_t *len)
+int uart_receive_data_with_dma(struct stm_uart *uart, const char **data, size_t *len)
 {
-	return dma_ring_buffer_periph_to_mem_get_data(&ring_buff_rx, (const volatile void **)data, len);
+	if (!uart)
+		return -1000;
+
+	return dma_ring_buffer_periph_to_mem_get_data(&uart->rx_ring_buff, (const volatile void **)data, len);
 }
 
-void DMA2_Stream7_IRQHandler()
+char uart_get_char(struct stm_uart *uart)
 {
-	uint32_t hisr = DMA2->HISR;
+	if (!uart)
-	DMA2->HIFCR = hisr;
+		return 0;
+	/* Wait for data to be available */
+	while (!(uart->uart_dev->SR & USART_SR_RXNE));
 
-	if (hisr & DMA_HISR_TCIF7) {
+	return (char)uart->uart_dev->DR;
-		dma_ring_buffer_mem_to_periph_int_callback(&ring_buff_tx);
+}
-	}
+
+int uart_check_rx_avail(struct stm_uart *uart)
+{
+	if (!uart)
+		return 0;
+
+	if (uart->uart_dev->SR & USART_SR_RXNE)
+		return 1;
+	else
+		return 0;
+}
+
+void uart_tx_dma_complete_int_callback(struct stm_uart *uart)
+{
+	if (!uart)
+		return;
+
+	dma_ring_buffer_mem_to_periph_int_callback(&uart->tx_ring_buff);
+}
+
+size_t uart_dma_tx_queue_avail(struct stm_uart *uart)
+{
+	size_t fill_level = 0UL;
+
+	if (!uart)
+		return 0UL;
+
+	(void)dma_ring_buffer_mem_to_periph_fill_level(&uart->tx_ring_buff, &fill_level);
+
+	return fill_level;
+}
+
+size_t uart_dma_rx_queue_avail(struct stm_uart *uart)
+{
+	size_t fill_level = 0UL;
+
+	if (!uart)
+		return 0UL;
+
+	(void)dma_ring_buffer_periph_to_mem_fill_level(&uart->rx_ring_buff, &fill_level);
+
+	return fill_level;
 }

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

@@ -8,7 +8,7 @@
  * 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,
+ * 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.

stm-firmware/stm32f407vet6_flash.ld

@@ -112,13 +112,8 @@ SECTIONS
 
   _siccmram = LOADADDR(.ccmram);
 
-  /* CCM-RAM section 
+  /* CCM-RAM section  */
-  * 
+  .ccmram (NOLOAD):
-  * IMPORTANT NOTE! 
-  * If initialized variables will be placed in this section, 
-  * the startup code needs to be modified to copy the init-values.  
-  */
-  .ccmram :
   {
     . = ALIGN(4);
     _sccmram = .;       /* create a global symbol at ccmram start */
@@ -126,12 +121,12 @@ SECTIONS
     *(.ccmram*)
     . = ALIGN(4);
     _eccmram = .;       /* create a global symbol at ccmram end */
-  } >CCM AT> FLASH
+  } >CCM
 
  _sidata = LOADADDR(.data);
 
   /* Initialized data sections goes into RAM, load LMA copy after code */
-  .data : 
+ .data : 
   {
     . = ALIGN(4);
     _sdata = .;        /* create a global symbol at data start */

stm-firmware/syscalls.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -23,6 +23,7 @@
 #include <errno.h>
 #include <stddef.h>
 
+extern struct stm_uart shell_uart;
 
 char* _sbrk(int incr)
 {
@@ -87,6 +88,25 @@ int _read(void)
 int _write(int fd, const void *buf, int count)
 {
 	if (fd == 1)
-		uart_send_array_with_dma((char*)buf, count);
+		uart_send_array_with_dma(&shell_uart, (char *)buf, count);
+	else if (fd == 2) {
+		uart_send_string_with_dma(&shell_uart, "\e[31m");
+		uart_send_array_with_dma(&shell_uart, (char *)buf, count);
+		uart_send_string_with_dma(&shell_uart, "\e[m");
+	}
+
 	return count;
 }
+
+int _getpid()
+{
+	return 0;
+}
+
+int _kill(int pid)
+{
+	(void)pid;
+
+	return -1;
+}
+

stm-firmware/systick.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.
@@ -26,12 +26,13 @@
 #include <stm32/stm32f4xx.h>
 #include <cmsis/core_cm4.h>
 
-volatile uint32_t wait_tick_ms;
+volatile uint32_t wait_tick_ms = 0UL;
-volatile uint64_t global_tick_ms;
+volatile uint64_t global_tick_ms = 0ULL;
+volatile uint32_t lcd_tick_100us = 0UL;
 
 void systick_setup(void)
 {
-	/* Setup Systick for 1ms tick @ 168 MHz Clock Speed */
+	/* Setup Systick for 100us tick @ 168 MHz Clock Speed */
 	SysTick_Config(SYSTICK_RELOAD);
 }
 
@@ -41,6 +42,66 @@ void systick_wait_ms(uint32_t ms)
 	while (wait_tick_ms < ms);
 }
 
+uint64_t systick_get_global_tick()
+{
+	uint64_t temp;
+
+	__disable_irq();
+	temp = global_tick_ms;
+	__enable_irq();
+
+	return temp;
+}
+
+void systick_get_uptime_from_tick(uint32_t *days, uint32_t *hours, uint32_t *minutes, uint32_t *seconds)
+{
+	uint64_t tick_secs;
+	uint32_t secs;
+	uint32_t mins;
+	uint32_t hs;
+	uint32_t ds;
+
+
+	tick_secs = systick_get_global_tick() / 1000;
+	secs = tick_secs % 60;
+	tick_secs /= 60;
+	mins = tick_secs % 60;
+	tick_secs /= 60;
+	hs = tick_secs % 60;
+	tick_secs /= 24;
+	ds = tick_secs;
+
+	if (days)
+		*days = ds;
+	if (hours)
+		*hours = hs;
+	if (minutes)
+		*minutes = mins;
+	if (seconds)
+		*seconds = secs;
+
+}
+
+bool __attribute__((optimize("O3"))) systick_ticks_have_passed(uint64_t start_timestamp, uint64_t ticks)
+{
+	uint64_t end_timestamp = start_timestamp + ticks;
+	uint64_t current_timestamp = systick_get_global_tick();
+
+	/* wrap around expected */
+	if (end_timestamp < start_timestamp) {
+		/* Wrap around occured */
+		if (current_timestamp < start_timestamp) {
+			if (current_timestamp >= end_timestamp)
+				return true;
+		}
+	} else {
+		if (current_timestamp >= end_timestamp)
+			return true;
+	}
+
+	return false;
+}
+
 /**
  * @brief Interrupt Handler for SysTick
  *
@@ -48,9 +109,16 @@ void systick_wait_ms(uint32_t ms)
  *
  * @warning For calling cyclic functions use separate timers/flags and don't spoil this function
  */
-void SysTick_Handler()
+void __attribute__((optimize("O3"))) SysTick_Handler()
 {
-	/* Increase tick counters */
+	static uint32_t pre_tick = 0UL;
-	wait_tick_ms++;
+
-	global_tick_ms++;
+	pre_tick++;
+	if (pre_tick == 10) {
+		pre_tick = 0;
+		/* Increase tick counters */
+		wait_tick_ms++;
+		global_tick_ms++;
+	}
+	lcd_tick_100us++;
 }

stm-firmware/temp-converter.c

@@ -8,7 +8,7 @@
  * 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,
+ * 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.

stm-firmware/ui/lcd.c

@@ -0,0 +1,464 @@
+/* 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/>.
+*/
+
+/* Thanks to
+ * https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
+ * for the basic code construct
+ */
+
+#include <stm32/stm32f4xx.h>
+#include <reflow-controller/ui/lcd.h>
+#include <reflow-controller/systick.h>
+#include <stm-periph/clock-enable-manager.h>
+#include <stm-periph/stm32-gpio-macros.h>
+#include <stdbool.h>
+#include <string.h>
+
+static void lcd_port_clear(void)
+{
+	LCD_DPORT->ODR &= ~(LCD_E_MASK);
+	LCD_DPORT->ODR &= ~(LCD_DATA_MASK | LCD_RS_MASK | LCD_E_MASK);
+}
+
+static void lcd_enable(void)
+{
+	LCD_DPORT->ODR |= LCD_E_MASK;
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	//systick_wait_ms(10);
+	LCD_DPORT->ODR &= ~LCD_E_MASK;
+	//systick_wait_ms(10);
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+}
+
+static void lcd_out(uint8_t data)
+{
+	LCD_DPORT->ODR &= ~(LCD_DATA_MASK);
+	LCD_DPORT->ODR |= (data << LCD_DATA_BIT_OFFSET) & LCD_DATA_MASK;
+}
+
+static void lcd_data(uint8_t data)
+{
+	lcd_port_clear();
+	LCD_DPORT->ODR |= LCD_RS_MASK;
+	lcd_out((data>>4) & 0xFU);
+	lcd_enable();
+	lcd_out(data & 0xFU);
+	lcd_enable();
+	systick_wait_ms(1);
+}
+
+static void lcd_command(uint8_t data)
+{
+	lcd_port_clear();
+	lcd_out((data>>4) & 0xFU);
+	lcd_enable();
+	lcd_out(data & 0xFU);
+	lcd_enable();
+	systick_wait_ms(1);
+}
+
+#define LCD_DDADR_LINE1         0x00
+#define LCD_DDADR_LINE2         0x40
+#define LCD_DDADR_LINE3         0x10
+#define LCD_DDADR_LINE4         0x50
+
+// Clear Display -------------- 0b00000001
+#define LCD_CLEAR_DISPLAY       0x01
+
+// Cursor Home ---------------- 0b0000001x
+#define LCD_CURSOR_HOME         0x02
+
+// Set Entry Mode ------------- 0b000001xx
+#define LCD_SET_ENTRY           0x04
+
+#define LCD_ENTRY_DECREASE      0x00
+#define LCD_ENTRY_INCREASE      0x02
+#define LCD_ENTRY_NOSHIFT       0x00
+#define LCD_ENTRY_SHIFT         0x01
+
+// Set Display ---------------- 0b00001xxx
+#define LCD_SET_DISPLAY         0x08
+
+#define LCD_DISPLAY_OFF         0x00
+#define LCD_DISPLAY_ON          0x04
+#define LCD_CURSOR_OFF          0x00
+#define LCD_CURSOR_ON           0x02
+#define LCD_BLINKING_OFF        0x00
+#define LCD_BLINKING_ON         0x01
+
+// Set Shift ------------------ 0b0001xxxx
+#define LCD_SET_SHIFT           0x10
+
+#define LCD_CURSOR_MOVE         0x00
+#define LCD_DISPLAY_SHIFT       0x08
+#define LCD_SHIFT_LEFT          0x00
+#define LCD_SHIFT_RIGHT         0x04
+
+// Set Function --------------- 0b001xxxxx
+#define LCD_SET_FUNCTION        0x20
+
+#define LCD_FUNCTION_4BIT       0x00
+#define LCD_FUNCTION_8BIT       0x10
+#define LCD_FUNCTION_1LINE      0x00
+#define LCD_FUNCTION_2LINE      0x08
+#define LCD_FUNCTION_5X7        0x00
+#define LCD_FUNCTION_5X10       0x04
+
+#define LCD_SOFT_RESET          0x30
+
+// Set CG RAM Address --------- 0b01xxxxxx  (Character Generator RAM)
+#define LCD_SET_CGADR           0x40
+
+#define LCD_GC_CHAR0            0
+#define LCD_GC_CHAR1            1
+#define LCD_GC_CHAR2            2
+#define LCD_GC_CHAR3            3
+#define LCD_GC_CHAR4            4
+#define LCD_GC_CHAR5            5
+#define LCD_GC_CHAR6            6
+#define LCD_GC_CHAR7            7
+
+// Set DD RAM Address --------- 0b1xxxxxxx  (Display Data RAM)
+#define LCD_SET_DDADR           0x80
+
+static char __attribute__((section(".ccmram"))) shadow_display[4][21];
+
+void lcd_clear(void)
+{
+	lcd_command(LCD_CLEAR_DISPLAY);
+	systick_wait_ms(3);
+}
+
+void lcd_home(void)
+{
+	lcd_command(LCD_CURSOR_HOME);
+	systick_wait_ms(3);
+}
+
+static uint8_t lcd_get_set_cursor_cmd(uint8_t x, uint8_t y)
+{
+	uint8_t data;
+
+	switch (y) {
+	case 0:
+		/* First line */
+		data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
+		break;
+
+	case 1:
+		/* Second Line */
+		data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
+		break;
+
+	case 2:
+		/* Third line */
+		data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
+		break;
+
+	case 3:
+		/* Fourth line */
+		data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
+		break;
+
+	default:
+		/* In case of wrong line, assume first line */
+		data = LCD_SET_DDADR + LCD_DDADR_LINE1;
+		break;
+	}
+
+	return data;
+}
+
+void lcd_setcursor(uint8_t x, uint8_t y)
+{
+	uint8_t data;
+
+	data = lcd_get_set_cursor_cmd(x, y);
+	lcd_command(data);
+}
+
+void lcd_string(const char *data)
+{
+	while (*data != '\0')
+		lcd_data((uint8_t)*data++);
+}
+
+static void lcd_port_init()
+{
+	LCD_DPORT->MODER &= MODER_DELETE(LCD_E) & MODER_DELETE(LCD_RS) & MODER_DELETE(LCD_DATA_BIT_OFFSET) &
+			MODER_DELETE(LCD_DATA_BIT_OFFSET + 1) & MODER_DELETE(LCD_DATA_BIT_OFFSET + 2) &
+			MODER_DELETE(LCD_DATA_BIT_OFFSET + 3);
+
+	LCD_DPORT->MODER |= OUTPUT(LCD_E) | OUTPUT(LCD_RS) | OUTPUT(LCD_DATA_BIT_OFFSET) |
+			OUTPUT(LCD_DATA_BIT_OFFSET + 1) | OUTPUT(LCD_DATA_BIT_OFFSET + 2) |
+			OUTPUT(LCD_DATA_BIT_OFFSET + 3);
+}
+
+static void lcd_clear_shadow_buff()
+{
+	int i, j;
+
+	for (i = 0; i < 4; i++) {
+		for (j = 0; j < 21; j++) {
+			shadow_display[i][j] = 0x0;
+		}
+	}
+}
+
+void lcd_init(void)
+{
+	int i;
+
+	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(LCD_RCC_MASK));
+	lcd_port_init();
+	lcd_port_clear();
+
+	lcd_clear_shadow_buff();
+
+	systick_wait_ms(100);
+	LCD_DPORT->ODR |= (0x3 << LCD_DATA_BIT_OFFSET);
+
+	for (i = 0; i < 3; i++) {
+		lcd_enable();
+		systick_wait_ms(5);
+	}
+
+	// Set 4 Bit mode
+	lcd_port_clear();
+	LCD_DPORT->ODR |= (0x2<<LCD_DATA_BIT_OFFSET);
+	lcd_enable();
+	systick_wait_ms(2);
+
+	/* 4 Bit mode 2 lines */
+	lcd_command( LCD_SET_FUNCTION |
+		     LCD_FUNCTION_4BIT |
+		     LCD_FUNCTION_2LINE |
+		     LCD_FUNCTION_5X7 );
+
+	/* Display on without cursor */
+	lcd_command( LCD_SET_DISPLAY |
+		     LCD_DISPLAY_ON |
+		     LCD_CURSOR_OFF |
+		     LCD_BLINKING_OFF);
+
+	/* Cursor increment, no scroll */
+	lcd_command( LCD_SET_ENTRY |
+		     LCD_ENTRY_INCREASE |
+		     LCD_ENTRY_NOSHIFT );
+
+	lcd_clear();
+}
+
+void lcd_deinit()
+{
+	lcd_port_clear();
+	rcc_manager_disable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(LCD_RCC_MASK));
+}
+
+static uint8_t compare_input_to_shadow(const char (*display_buffer)[21])
+{
+	uint8_t ret = 0;
+	int i, row;
+
+	for (row = 0; row < 4; row++) {
+		for (i = 0; i < 20; i++) {
+			if (display_buffer[row][i] != shadow_display[row][i]) {
+				ret |= (1U<<row);
+				break;
+			}
+		}
+	}
+
+	return ret;
+}
+
+static void lcd_fsm_enable(bool en)
+{
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	if (en)
+		LCD_DPORT->ODR |= LCD_E_MASK;
+	else
+		LCD_DPORT->ODR &= ~LCD_E_MASK;
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+	__ASM("nop");
+}
+
+static void lcd_fsm_write_command(bool high, uint8_t cmd)
+{
+	lcd_port_clear();
+
+	if (high)
+		lcd_out((cmd >> 4) & 0x0F);
+	else
+		lcd_out((cmd) & 0x0F);
+}
+
+static void lcd_fsm_write_data(bool high, uint8_t data)
+{
+	LCD_DPORT->ODR |= (1<<LCD_RS);
+	if (high)
+		lcd_out((data >> 4) & 0x0F);
+	else
+		lcd_out((data) & 0x0F);
+}
+
+enum lcd_fsm_ret lcd_fsm_write_buffer(const char (*display_buffer)[21])
+{
+	static bool idle = true;
+	static uint8_t rows_to_handle = 0;
+	static uint32_t state_cnt;
+	static uint8_t row_cnt = 0;
+	static uint32_t char_cnt;
+	static uint32_t line_len;
+	static uint64_t timestamp = 0ULL;
+	enum lcd_fsm_ret ret;
+
+	ret = LCD_FSM_NOP;
+
+	if (idle) {
+		rows_to_handle = compare_input_to_shadow(display_buffer);
+		memcpy(shadow_display, display_buffer, sizeof(shadow_display));
+		shadow_display[0][20] = 0;
+		shadow_display[1][20] = 0;
+		shadow_display[2][20] = 0;
+		shadow_display[3][20] = 0;
+		state_cnt = 0;
+		row_cnt = 0;
+		idle = false;
+	}
+
+	if (rows_to_handle == 0) {
+		idle = true;
+		return ret;
+	}
+
+	if ((rows_to_handle & (1<<row_cnt))) {
+		switch (state_cnt) {
+		case 0:
+			lcd_fsm_write_command(true, lcd_get_set_cursor_cmd(0, row_cnt));
+			line_len = strlen(&shadow_display[row_cnt][0]);
+			char_cnt = 0;
+			lcd_fsm_enable(true);
+			ret = LCD_FSM_WAIT_CALL;
+			state_cnt++;
+			break;
+		case 1:
+			lcd_fsm_enable(false);
+			ret = LCD_FSM_WAIT_CALL;
+			state_cnt++;
+			break;
+		case 2:
+			lcd_fsm_write_command(false, lcd_get_set_cursor_cmd(0, row_cnt));
+			lcd_fsm_enable(true);
+			ret = LCD_FSM_WAIT_CALL;
+			state_cnt++;
+			break;
+		case 3:
+			lcd_fsm_enable(false);
+			ret = LCD_FSM_WAIT_CALL;
+			timestamp = systick_get_global_tick();
+			state_cnt++;
+			break;
+		case 4:
+			if (!systick_ticks_have_passed(timestamp, 4)) {
+				ret = LCD_FSM_WAIT_CALL;
+			} else {
+				ret = LCD_FSM_CALL_AGAIN;
+				state_cnt++;
+			}
+			break;
+		case 5:
+			lcd_fsm_write_data(true, (char_cnt >= line_len) ? ' ' : shadow_display[row_cnt][char_cnt]);
+			lcd_fsm_enable(true);
+			ret = LCD_FSM_CALL_AGAIN;
+			state_cnt++;
+			break;
+		case 6:
+			lcd_fsm_enable(false);
+			ret = LCD_FSM_WAIT_CALL;
+			state_cnt++;
+			break;
+		case 7:
+			lcd_fsm_write_data(false, (char_cnt >= line_len) ? ' ' : shadow_display[row_cnt][char_cnt]);
+			lcd_fsm_enable(true);
+			ret = LCD_FSM_CALL_AGAIN;
+			state_cnt++;
+			break;
+		case 8:
+			lcd_fsm_enable(false);
+			ret = LCD_FSM_WAIT_CALL;
+			char_cnt++;
+			if (char_cnt < LCD_CHAR_WIDTH) {
+				state_cnt = 5;
+			} else {
+				state_cnt = 0;
+				rows_to_handle &= (uint8_t)~(1U<<row_cnt);
+				if (row_cnt < 3) {
+					row_cnt++;
+				} else {
+					idle = true;
+					row_cnt = 0;
+				}
+			}
+			break;
+		default:
+			ret = LCD_FSM_NOP;
+			idle = true;
+			rows_to_handle = 0U;
+			break;
+		}
+	} else {
+		if (row_cnt < 3) {
+			row_cnt++;
+			ret = LCD_FSM_CALL_AGAIN;
+		} else {
+			row_cnt = 0;
+			ret = LCD_FSM_NOP;
+		}
+	}
+
+	return ret;
+}

stm-firmware/ui/menu.c

@@ -0,0 +1,255 @@
+/* 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/>.
+*/
+
+#include <reflow-controller/ui/menu.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+void menu_handle(struct lcd_menu *menu, int16_t rotary_encoder_delta, enum button_state push_button)
+{
+	menu_func_t tmp;
+
+	if (!menu)
+		return;
+
+	menu->inputs.push_button = push_button;
+	menu->inputs.rotary_encoder_delta += rotary_encoder_delta;
+
+	if (menu->active_entry == NULL)
+		menu->active_entry = menu->root_entry;
+
+	tmp = menu->active_entry;
+
+
+	if (menu->active_entry_type == MENU_ENTRY_FIRST_ENTER) {
+		menu->active_entry(menu, menu->active_entry_type, menu->init_parent);
+	} else {
+		menu->active_entry(menu, menu->active_entry_type, NULL);
+	}
+
+	if (menu->active_entry_type != MENU_ENTRY_CONTINUE && tmp == menu->active_entry) {
+		menu->active_entry_type = MENU_ENTRY_CONTINUE;
+	}
+}
+
+void menu_init(struct lcd_menu *menu, menu_func_t root_node, void (*display_update)(uint8_t row, const char *data))
+{
+	if (!menu)
+		return;
+
+	menu->root_entry = root_node;
+	menu->active_entry = root_node;
+	menu->init_parent = NULL;
+	menu->inputs.push_button = BUTTON_IDLE;
+	menu->inputs.rotary_encoder_delta = 0;
+	menu->active_entry_type = MENU_ENTRY_FIRST_ENTER;
+	menu->update_display = display_update;
+}
+
+void menu_entry_dropback(struct lcd_menu *menu, menu_func_t parent_func)
+{
+	if (!menu)
+		return;
+	if (parent_func)
+		menu->active_entry = parent_func;
+	else
+		menu->active_entry = menu->root_entry;
+
+	menu->active_entry_type = MENU_ENTRY_DROPBACK;
+}
+
+void menu_entry_enter(struct lcd_menu *menu, menu_func_t entry, bool handle_immediately)
+{
+	if (!menu)
+		return;
+
+	menu->init_parent = menu->active_entry;
+	menu->active_entry_type = MENU_ENTRY_FIRST_ENTER;
+	menu->active_entry = entry;
+
+	if (handle_immediately)
+		menu_handle(menu, menu->inputs.rotary_encoder_delta, menu->inputs.push_button);
+}
+
+void menu_lcd_output(struct lcd_menu *menu, uint8_t row_num, const char *text)
+{
+	if (!menu || !menu->update_display)
+		return;
+
+	menu->update_display(row_num, text);
+}
+
+void menu_lcd_outputf(struct lcd_menu *menu, uint8_t row_num, const char *format, ...)
+{
+	char buff[64];
+	va_list valist;
+
+	va_start(valist, format);
+	vsnprintf(buff, sizeof(buff), format, valist);
+	buff[sizeof(buff) - 1] = '\0';
+	menu_lcd_output(menu, row_num, buff);
+	va_end(valist);
+}
+
+void menu_list_display(struct menu_list *list, uint32_t top_row, uint32_t bottom_row)
+{
+	uint8_t row_count;
+	uint32_t mid_row;
+	uint32_t count_above_mid;
+	uint32_t count_below_mid;
+	uint32_t start_index;
+	uint32_t current_row;
+	uint32_t current_idx;
+	char workbuff[64];
+
+	if (!list || !list->update_display)
+		return;
+
+	if (bottom_row < top_row)
+		return;
+
+	if (list->entry_count == 0) {
+		for (current_row = top_row; current_row <= bottom_row; current_row++) {
+			list->update_display((uint8_t)current_row, "");
+		}
+		return;
+	}
+
+	/* Calculate list parameters */
+	row_count = bottom_row - top_row + 1;
+	mid_row = (top_row + bottom_row) / 2;
+	count_above_mid = mid_row - top_row;
+	count_below_mid = bottom_row - mid_row;
+
+	/* Check if there are more elements above the and below the currently selected one that can be displayed. in this case position
+	 * active entry in center
+	 */
+	if (list->currently_selected > count_above_mid && (list->entry_count - list->currently_selected - 1) > count_below_mid) {
+		start_index = list->currently_selected - count_above_mid;
+	} else if (list->currently_selected < count_above_mid) {
+		start_index = 0;
+	} else if ((list->entry_count - list->currently_selected - 1) <= count_below_mid) {
+		if (list->entry_count < row_count)
+			start_index = 0;
+		else
+			start_index = list->entry_count - row_count;
+	} else {
+		start_index = 0;
+	}
+
+	for (current_row = top_row, current_idx = start_index; current_row <= bottom_row; current_row++, current_idx++) {
+		if (current_idx >= list->entry_count)
+			break;
+
+		snprintf(workbuff, sizeof(workbuff), "%c%s", (current_idx == list->currently_selected ? '>' : ' '),
+			 list->entry_names[current_idx]);
+		workbuff[sizeof(workbuff)-1] = 0;
+		list->update_display((uint8_t)current_row, workbuff);
+	}
+
+}
+
+void menu_list_compute_count(struct menu_list *list)
+{
+	uint32_t count = 0;
+
+	if (!list)
+		return;
+
+	for (count = 0; list->entry_names[count] != NULL; count++);
+	list->entry_count = count;
+}
+
+void menu_list_scroll_down(struct menu_list *list)
+{
+	if (!list)
+		return;
+
+	if (list->currently_selected < list->entry_count - 1) {
+		list->currently_selected++;
+	}
+}
+
+void menu_list_enter_selected_entry(struct menu_list *list, struct lcd_menu *menu)
+{
+	menu_func_t entry;
+
+	if (!list)
+		return;
+
+	if (!list->submenu_list)
+		return;
+
+	entry = list->submenu_list[list->currently_selected];
+
+	if (!entry)
+		return;
+
+	menu_entry_enter(menu, entry, false);
+}
+
+void menu_list_scroll_up(struct menu_list *list)
+{
+	if (!list)
+		return;
+
+	if (list->currently_selected > 0)
+		list->currently_selected--;
+}
+
+void menu_ack_rotary_delta(struct lcd_menu *menu)
+{
+	if (!menu)
+		return;
+
+	menu->inputs.rotary_encoder_delta = 0;
+}
+
+int16_t menu_get_rotary_delta(const struct lcd_menu *menu)
+{
+	int16_t ret = 0;
+
+	if (menu)
+		ret = menu->inputs.rotary_encoder_delta;
+
+	return ret;
+}
+
+enum button_state menu_get_button_state(const struct lcd_menu *menu)
+{
+	enum button_state ret = BUTTON_IDLE;
+
+	if (menu)
+		ret = menu->inputs.push_button;
+
+	return ret;
+}
+
+void menu_display_clear(struct lcd_menu *menu)
+{
+	uint8_t i;
+
+	if (!menu || !menu->update_display)
+		return;
+
+	for (i = 0; i < 4; i++)
+		menu->update_display(i, "");
+}